steam-vent-proto 0.1.0

// This file is generated by rust-protobuf 2.24.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `steamnetworkingsockets_messages_udp.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_24_1;

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_ChallengeRequest {
    // message fields
    connection_id: ::std::option::Option<u32>,
    my_timestamp: ::std::option::Option<u64>,
    protocol_version: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_ChallengeRequest {
    fn default() -> &'a CMsgSteamSockets_UDP_ChallengeRequest {
        <CMsgSteamSockets_UDP_ChallengeRequest as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_ChallengeRequest {
    pub fn new() -> CMsgSteamSockets_UDP_ChallengeRequest {
        ::std::default::Default::default()
    }

    // optional fixed32 connection_id = 1;


    pub fn get_connection_id(&self) -> u32 {
        self.connection_id.unwrap_or(0)
    }
    pub fn clear_connection_id(&mut self) {
        self.connection_id = ::std::option::Option::None;
    }

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connection_id(&mut self, v: u32) {
        self.connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed64 my_timestamp = 3;


    pub fn get_my_timestamp(&self) -> u64 {
        self.my_timestamp.unwrap_or(0)
    }
    pub fn clear_my_timestamp(&mut self) {
        self.my_timestamp = ::std::option::Option::None;
    }

    pub fn has_my_timestamp(&self) -> bool {
        self.my_timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_my_timestamp(&mut self, v: u64) {
        self.my_timestamp = ::std::option::Option::Some(v);
    }

    // optional uint32 protocol_version = 4;


    pub fn get_protocol_version(&self) -> u32 {
        self.protocol_version.unwrap_or(0)
    }
    pub fn clear_protocol_version(&mut self) {
        self.protocol_version = ::std::option::Option::None;
    }

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_protocol_version(&mut self, v: u32) {
        self.protocol_version = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_ChallengeRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.connection_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.my_timestamp = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.protocol_version = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 5;
        }
        if let Some(v) = self.my_timestamp {
            my_size += 9;
        }
        if let Some(v) = self.protocol_version {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.my_timestamp {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.protocol_version {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_ChallengeRequest {
        CMsgSteamSockets_UDP_ChallengeRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "connection_id",
                |m: &CMsgSteamSockets_UDP_ChallengeRequest| { &m.connection_id },
                |m: &mut CMsgSteamSockets_UDP_ChallengeRequest| { &mut m.connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "my_timestamp",
                |m: &CMsgSteamSockets_UDP_ChallengeRequest| { &m.my_timestamp },
                |m: &mut CMsgSteamSockets_UDP_ChallengeRequest| { &mut m.my_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "protocol_version",
                |m: &CMsgSteamSockets_UDP_ChallengeRequest| { &m.protocol_version },
                |m: &mut CMsgSteamSockets_UDP_ChallengeRequest| { &mut m.protocol_version },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_ChallengeRequest>(
                "CMsgSteamSockets_UDP_ChallengeRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_ChallengeRequest {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_ChallengeRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_ChallengeRequest::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_ChallengeRequest {
    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.my_timestamp = ::std::option::Option::None;
        self.protocol_version = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_ChallengeRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_ChallengeRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_ChallengeReply {
    // message fields
    connection_id: ::std::option::Option<u32>,
    challenge: ::std::option::Option<u64>,
    your_timestamp: ::std::option::Option<u64>,
    protocol_version: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_ChallengeReply {
    fn default() -> &'a CMsgSteamSockets_UDP_ChallengeReply {
        <CMsgSteamSockets_UDP_ChallengeReply as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_ChallengeReply {
    pub fn new() -> CMsgSteamSockets_UDP_ChallengeReply {
        ::std::default::Default::default()
    }

    // optional fixed32 connection_id = 1;


    pub fn get_connection_id(&self) -> u32 {
        self.connection_id.unwrap_or(0)
    }
    pub fn clear_connection_id(&mut self) {
        self.connection_id = ::std::option::Option::None;
    }

    pub fn has_connection_id(&self) -> bool {
        self.connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connection_id(&mut self, v: u32) {
        self.connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed64 challenge = 2;


    pub fn get_challenge(&self) -> u64 {
        self.challenge.unwrap_or(0)
    }
    pub fn clear_challenge(&mut self) {
        self.challenge = ::std::option::Option::None;
    }

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

    // Param is passed by value, moved
    pub fn set_challenge(&mut self, v: u64) {
        self.challenge = ::std::option::Option::Some(v);
    }

    // optional fixed64 your_timestamp = 3;


    pub fn get_your_timestamp(&self) -> u64 {
        self.your_timestamp.unwrap_or(0)
    }
    pub fn clear_your_timestamp(&mut self) {
        self.your_timestamp = ::std::option::Option::None;
    }

    pub fn has_your_timestamp(&self) -> bool {
        self.your_timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_your_timestamp(&mut self, v: u64) {
        self.your_timestamp = ::std::option::Option::Some(v);
    }

    // optional uint32 protocol_version = 4;


    pub fn get_protocol_version(&self) -> u32 {
        self.protocol_version.unwrap_or(0)
    }
    pub fn clear_protocol_version(&mut self) {
        self.protocol_version = ::std::option::Option::None;
    }

    pub fn has_protocol_version(&self) -> bool {
        self.protocol_version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_protocol_version(&mut self, v: u32) {
        self.protocol_version = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_ChallengeReply {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.connection_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.challenge = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.your_timestamp = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.protocol_version = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.connection_id {
            my_size += 5;
        }
        if let Some(v) = self.challenge {
            my_size += 9;
        }
        if let Some(v) = self.your_timestamp {
            my_size += 9;
        }
        if let Some(v) = self.protocol_version {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.challenge {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.your_timestamp {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.protocol_version {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_ChallengeReply {
        CMsgSteamSockets_UDP_ChallengeReply::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "connection_id",
                |m: &CMsgSteamSockets_UDP_ChallengeReply| { &m.connection_id },
                |m: &mut CMsgSteamSockets_UDP_ChallengeReply| { &mut m.connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "challenge",
                |m: &CMsgSteamSockets_UDP_ChallengeReply| { &m.challenge },
                |m: &mut CMsgSteamSockets_UDP_ChallengeReply| { &mut m.challenge },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "your_timestamp",
                |m: &CMsgSteamSockets_UDP_ChallengeReply| { &m.your_timestamp },
                |m: &mut CMsgSteamSockets_UDP_ChallengeReply| { &mut m.your_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "protocol_version",
                |m: &CMsgSteamSockets_UDP_ChallengeReply| { &m.protocol_version },
                |m: &mut CMsgSteamSockets_UDP_ChallengeReply| { &mut m.protocol_version },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_ChallengeReply>(
                "CMsgSteamSockets_UDP_ChallengeReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_ChallengeReply {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_ChallengeReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_ChallengeReply::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_ChallengeReply {
    fn clear(&mut self) {
        self.connection_id = ::std::option::Option::None;
        self.challenge = ::std::option::Option::None;
        self.your_timestamp = ::std::option::Option::None;
        self.protocol_version = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_ChallengeReply {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_ChallengeReply {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_ConnectRequest {
    // message fields
    client_connection_id: ::std::option::Option<u32>,
    challenge: ::std::option::Option<u64>,
    my_timestamp: ::std::option::Option<u64>,
    ping_est_ms: ::std::option::Option<u32>,
    pub crypt: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned>,
    pub cert: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    legacy_protocol_version: ::std::option::Option<u32>,
    identity_string: ::protobuf::SingularField<::std::string::String>,
    legacy_client_steam_id: ::std::option::Option<u64>,
    pub legacy_identity_binary: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_ConnectRequest {
    fn default() -> &'a CMsgSteamSockets_UDP_ConnectRequest {
        <CMsgSteamSockets_UDP_ConnectRequest as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_ConnectRequest {
    pub fn new() -> CMsgSteamSockets_UDP_ConnectRequest {
        ::std::default::Default::default()
    }

    // optional fixed32 client_connection_id = 1;


    pub fn get_client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }
    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed64 challenge = 2;


    pub fn get_challenge(&self) -> u64 {
        self.challenge.unwrap_or(0)
    }
    pub fn clear_challenge(&mut self) {
        self.challenge = ::std::option::Option::None;
    }

    pub fn has_challenge(&self) -> bool {
        self.challenge.is_some()
    }

    // Param is passed by value, moved
    pub fn set_challenge(&mut self, v: u64) {
        self.challenge = ::std::option::Option::Some(v);
    }

    // optional fixed64 my_timestamp = 5;


    pub fn get_my_timestamp(&self) -> u64 {
        self.my_timestamp.unwrap_or(0)
    }
    pub fn clear_my_timestamp(&mut self) {
        self.my_timestamp = ::std::option::Option::None;
    }

    pub fn has_my_timestamp(&self) -> bool {
        self.my_timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_my_timestamp(&mut self, v: u64) {
        self.my_timestamp = ::std::option::Option::Some(v);
    }

    // optional uint32 ping_est_ms = 6;


    pub fn get_ping_est_ms(&self) -> u32 {
        self.ping_est_ms.unwrap_or(0)
    }
    pub fn clear_ping_est_ms(&mut self) {
        self.ping_est_ms = ::std::option::Option::None;
    }

    pub fn has_ping_est_ms(&self) -> bool {
        self.ping_est_ms.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ping_est_ms(&mut self, v: u32) {
        self.ping_est_ms = ::std::option::Option::Some(v);
    }

    // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;


    pub fn get_crypt(&self) -> &super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned {
        self.crypt.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned as ::protobuf::Message>::default_instance())
    }
    pub fn clear_crypt(&mut self) {
        self.crypt.clear();
    }

    pub fn has_crypt(&self) -> bool {
        self.crypt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_crypt(&mut self, v: super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned) {
        self.crypt = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_crypt(&mut self) -> &mut super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned {
        if self.crypt.is_none() {
            self.crypt.set_default();
        }
        self.crypt.as_mut().unwrap()
    }

    // Take field
    pub fn take_crypt(&mut self) -> super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned {
        self.crypt.take().unwrap_or_else(|| super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned::new())
    }

    // optional .CMsgSteamDatagramCertificateSigned cert = 4;


    pub fn get_cert(&self) -> &super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        self.cert.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned as ::protobuf::Message>::default_instance())
    }
    pub fn clear_cert(&mut self) {
        self.cert.clear();
    }

    pub fn has_cert(&self) -> bool {
        self.cert.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cert(&mut self, v: super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned) {
        self.cert = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cert(&mut self) -> &mut super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        if self.cert.is_none() {
            self.cert.set_default();
        }
        self.cert.as_mut().unwrap()
    }

    // Take field
    pub fn take_cert(&mut self) -> super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        self.cert.take().unwrap_or_else(|| super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned::new())
    }

    // optional uint32 legacy_protocol_version = 8;


    pub fn get_legacy_protocol_version(&self) -> u32 {
        self.legacy_protocol_version.unwrap_or(0)
    }
    pub fn clear_legacy_protocol_version(&mut self) {
        self.legacy_protocol_version = ::std::option::Option::None;
    }

    pub fn has_legacy_protocol_version(&self) -> bool {
        self.legacy_protocol_version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_protocol_version(&mut self, v: u32) {
        self.legacy_protocol_version = ::std::option::Option::Some(v);
    }

    // optional string identity_string = 10;


    pub fn get_identity_string(&self) -> &str {
        match self.identity_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_identity_string(&mut self) {
        self.identity_string.clear();
    }

    pub fn has_identity_string(&self) -> bool {
        self.identity_string.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identity_string(&mut self, v: ::std::string::String) {
        self.identity_string = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_identity_string(&mut self) -> &mut ::std::string::String {
        if self.identity_string.is_none() {
            self.identity_string.set_default();
        }
        self.identity_string.as_mut().unwrap()
    }

    // Take field
    pub fn take_identity_string(&mut self) -> ::std::string::String {
        self.identity_string.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional fixed64 legacy_client_steam_id = 3;


    pub fn get_legacy_client_steam_id(&self) -> u64 {
        self.legacy_client_steam_id.unwrap_or(0)
    }
    pub fn clear_legacy_client_steam_id(&mut self) {
        self.legacy_client_steam_id = ::std::option::Option::None;
    }

    pub fn has_legacy_client_steam_id(&self) -> bool {
        self.legacy_client_steam_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_client_steam_id(&mut self, v: u64) {
        self.legacy_client_steam_id = ::std::option::Option::Some(v);
    }

    // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 9;


    pub fn get_legacy_identity_binary(&self) -> &super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary {
        self.legacy_identity_binary.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary as ::protobuf::Message>::default_instance())
    }
    pub fn clear_legacy_identity_binary(&mut self) {
        self.legacy_identity_binary.clear();
    }

    pub fn has_legacy_identity_binary(&self) -> bool {
        self.legacy_identity_binary.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_identity_binary(&mut self, v: super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary) {
        self.legacy_identity_binary = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_legacy_identity_binary(&mut self) -> &mut super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary {
        if self.legacy_identity_binary.is_none() {
            self.legacy_identity_binary.set_default();
        }
        self.legacy_identity_binary.as_mut().unwrap()
    }

    // Take field
    pub fn take_legacy_identity_binary(&mut self) -> super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary {
        self.legacy_identity_binary.take().unwrap_or_else(|| super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary::new())
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_ConnectRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.crypt {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.cert {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.legacy_identity_binary {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.client_connection_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.challenge = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.my_timestamp = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.ping_est_ms = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.crypt)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cert)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.legacy_protocol_version = ::std::option::Option::Some(tmp);
                },
                10 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.identity_string)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.legacy_client_steam_id = ::std::option::Option::Some(tmp);
                },
                9 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.legacy_identity_binary)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.client_connection_id {
            my_size += 5;
        }
        if let Some(v) = self.challenge {
            my_size += 9;
        }
        if let Some(v) = self.my_timestamp {
            my_size += 9;
        }
        if let Some(v) = self.ping_est_ms {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.crypt.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(v) = self.legacy_protocol_version {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.identity_string.as_ref() {
            my_size += ::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.legacy_client_steam_id {
            my_size += 9;
        }
        if let Some(ref v) = self.legacy_identity_binary.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.challenge {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.my_timestamp {
            os.write_fixed64(5, v)?;
        }
        if let Some(v) = self.ping_est_ms {
            os.write_uint32(6, v)?;
        }
        if let Some(ref v) = self.crypt.as_ref() {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.cert.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(v) = self.legacy_protocol_version {
            os.write_uint32(8, v)?;
        }
        if let Some(ref v) = self.identity_string.as_ref() {
            os.write_string(10, &v)?;
        }
        if let Some(v) = self.legacy_client_steam_id {
            os.write_fixed64(3, v)?;
        }
        if let Some(ref v) = self.legacy_identity_binary.as_ref() {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_ConnectRequest {
        CMsgSteamSockets_UDP_ConnectRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "client_connection_id",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.client_connection_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.client_connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "challenge",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.challenge },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.challenge },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "my_timestamp",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.my_timestamp },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.my_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "ping_est_ms",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.ping_est_ms },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.ping_est_ms },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned>>(
                "crypt",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.crypt },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.crypt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>>(
                "cert",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.cert },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.cert },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "legacy_protocol_version",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.legacy_protocol_version },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.legacy_protocol_version },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "identity_string",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.identity_string },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.identity_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "legacy_client_steam_id",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.legacy_client_steam_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.legacy_client_steam_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary>>(
                "legacy_identity_binary",
                |m: &CMsgSteamSockets_UDP_ConnectRequest| { &m.legacy_identity_binary },
                |m: &mut CMsgSteamSockets_UDP_ConnectRequest| { &mut m.legacy_identity_binary },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_ConnectRequest>(
                "CMsgSteamSockets_UDP_ConnectRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_ConnectRequest {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_ConnectRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_ConnectRequest::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_ConnectRequest {
    fn clear(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
        self.challenge = ::std::option::Option::None;
        self.my_timestamp = ::std::option::Option::None;
        self.ping_est_ms = ::std::option::Option::None;
        self.crypt.clear();
        self.cert.clear();
        self.legacy_protocol_version = ::std::option::Option::None;
        self.identity_string.clear();
        self.legacy_client_steam_id = ::std::option::Option::None;
        self.legacy_identity_binary.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_ConnectRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_ConnectRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_ConnectOK {
    // message fields
    client_connection_id: ::std::option::Option<u32>,
    server_connection_id: ::std::option::Option<u32>,
    your_timestamp: ::std::option::Option<u64>,
    delay_time_usec: ::std::option::Option<u32>,
    pub crypt: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned>,
    pub cert: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>,
    identity_string: ::protobuf::SingularField<::std::string::String>,
    legacy_server_steam_id: ::std::option::Option<u64>,
    pub legacy_identity_binary: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_ConnectOK {
    fn default() -> &'a CMsgSteamSockets_UDP_ConnectOK {
        <CMsgSteamSockets_UDP_ConnectOK as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_ConnectOK {
    pub fn new() -> CMsgSteamSockets_UDP_ConnectOK {
        ::std::default::Default::default()
    }

    // optional fixed32 client_connection_id = 1;


    pub fn get_client_connection_id(&self) -> u32 {
        self.client_connection_id.unwrap_or(0)
    }
    pub fn clear_client_connection_id(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
    }

    pub fn has_client_connection_id(&self) -> bool {
        self.client_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_client_connection_id(&mut self, v: u32) {
        self.client_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 server_connection_id = 5;


    pub fn get_server_connection_id(&self) -> u32 {
        self.server_connection_id.unwrap_or(0)
    }
    pub fn clear_server_connection_id(&mut self) {
        self.server_connection_id = ::std::option::Option::None;
    }

    pub fn has_server_connection_id(&self) -> bool {
        self.server_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_server_connection_id(&mut self, v: u32) {
        self.server_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed64 your_timestamp = 3;


    pub fn get_your_timestamp(&self) -> u64 {
        self.your_timestamp.unwrap_or(0)
    }
    pub fn clear_your_timestamp(&mut self) {
        self.your_timestamp = ::std::option::Option::None;
    }

    pub fn has_your_timestamp(&self) -> bool {
        self.your_timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_your_timestamp(&mut self, v: u64) {
        self.your_timestamp = ::std::option::Option::Some(v);
    }

    // optional uint32 delay_time_usec = 4;


    pub fn get_delay_time_usec(&self) -> u32 {
        self.delay_time_usec.unwrap_or(0)
    }
    pub fn clear_delay_time_usec(&mut self) {
        self.delay_time_usec = ::std::option::Option::None;
    }

    pub fn has_delay_time_usec(&self) -> bool {
        self.delay_time_usec.is_some()
    }

    // Param is passed by value, moved
    pub fn set_delay_time_usec(&mut self, v: u32) {
        self.delay_time_usec = ::std::option::Option::Some(v);
    }

    // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;


    pub fn get_crypt(&self) -> &super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned {
        self.crypt.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned as ::protobuf::Message>::default_instance())
    }
    pub fn clear_crypt(&mut self) {
        self.crypt.clear();
    }

    pub fn has_crypt(&self) -> bool {
        self.crypt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_crypt(&mut self, v: super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned) {
        self.crypt = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_crypt(&mut self) -> &mut super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned {
        if self.crypt.is_none() {
            self.crypt.set_default();
        }
        self.crypt.as_mut().unwrap()
    }

    // Take field
    pub fn take_crypt(&mut self) -> super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned {
        self.crypt.take().unwrap_or_else(|| super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned::new())
    }

    // optional .CMsgSteamDatagramCertificateSigned cert = 8;


    pub fn get_cert(&self) -> &super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        self.cert.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned as ::protobuf::Message>::default_instance())
    }
    pub fn clear_cert(&mut self) {
        self.cert.clear();
    }

    pub fn has_cert(&self) -> bool {
        self.cert.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cert(&mut self, v: super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned) {
        self.cert = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cert(&mut self) -> &mut super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        if self.cert.is_none() {
            self.cert.set_default();
        }
        self.cert.as_mut().unwrap()
    }

    // Take field
    pub fn take_cert(&mut self) -> super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned {
        self.cert.take().unwrap_or_else(|| super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned::new())
    }

    // optional string identity_string = 11;


    pub fn get_identity_string(&self) -> &str {
        match self.identity_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_identity_string(&mut self) {
        self.identity_string.clear();
    }

    pub fn has_identity_string(&self) -> bool {
        self.identity_string.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identity_string(&mut self, v: ::std::string::String) {
        self.identity_string = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_identity_string(&mut self) -> &mut ::std::string::String {
        if self.identity_string.is_none() {
            self.identity_string.set_default();
        }
        self.identity_string.as_mut().unwrap()
    }

    // Take field
    pub fn take_identity_string(&mut self) -> ::std::string::String {
        self.identity_string.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional fixed64 legacy_server_steam_id = 2;


    pub fn get_legacy_server_steam_id(&self) -> u64 {
        self.legacy_server_steam_id.unwrap_or(0)
    }
    pub fn clear_legacy_server_steam_id(&mut self) {
        self.legacy_server_steam_id = ::std::option::Option::None;
    }

    pub fn has_legacy_server_steam_id(&self) -> bool {
        self.legacy_server_steam_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_server_steam_id(&mut self, v: u64) {
        self.legacy_server_steam_id = ::std::option::Option::Some(v);
    }

    // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 10;


    pub fn get_legacy_identity_binary(&self) -> &super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary {
        self.legacy_identity_binary.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary as ::protobuf::Message>::default_instance())
    }
    pub fn clear_legacy_identity_binary(&mut self) {
        self.legacy_identity_binary.clear();
    }

    pub fn has_legacy_identity_binary(&self) -> bool {
        self.legacy_identity_binary.is_some()
    }

    // Param is passed by value, moved
    pub fn set_legacy_identity_binary(&mut self, v: super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary) {
        self.legacy_identity_binary = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_legacy_identity_binary(&mut self) -> &mut super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary {
        if self.legacy_identity_binary.is_none() {
            self.legacy_identity_binary.set_default();
        }
        self.legacy_identity_binary.as_mut().unwrap()
    }

    // Take field
    pub fn take_legacy_identity_binary(&mut self) -> super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary {
        self.legacy_identity_binary.take().unwrap_or_else(|| super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary::new())
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_ConnectOK {
    fn is_initialized(&self) -> bool {
        for v in &self.crypt {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.cert {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.legacy_identity_binary {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.client_connection_id = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.server_connection_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.your_timestamp = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.delay_time_usec = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.crypt)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cert)?;
                },
                11 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.identity_string)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.legacy_server_steam_id = ::std::option::Option::Some(tmp);
                },
                10 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.legacy_identity_binary)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.client_connection_id {
            my_size += 5;
        }
        if let Some(v) = self.server_connection_id {
            my_size += 5;
        }
        if let Some(v) = self.your_timestamp {
            my_size += 9;
        }
        if let Some(v) = self.delay_time_usec {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.crypt.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.cert.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.identity_string.as_ref() {
            my_size += ::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.legacy_server_steam_id {
            my_size += 9;
        }
        if let Some(ref v) = self.legacy_identity_binary.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.client_connection_id {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.server_connection_id {
            os.write_fixed32(5, v)?;
        }
        if let Some(v) = self.your_timestamp {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.delay_time_usec {
            os.write_uint32(4, v)?;
        }
        if let Some(ref v) = self.crypt.as_ref() {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.cert.as_ref() {
            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.identity_string.as_ref() {
            os.write_string(11, &v)?;
        }
        if let Some(v) = self.legacy_server_steam_id {
            os.write_fixed64(2, v)?;
        }
        if let Some(ref v) = self.legacy_identity_binary.as_ref() {
            os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_ConnectOK {
        CMsgSteamSockets_UDP_ConnectOK::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "client_connection_id",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.client_connection_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.client_connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "server_connection_id",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.server_connection_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.server_connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "your_timestamp",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.your_timestamp },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.your_timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "delay_time_usec",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.delay_time_usec },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.delay_time_usec },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages::CMsgSteamDatagramSessionCryptInfoSigned>>(
                "crypt",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.crypt },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.crypt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages_certs::CMsgSteamDatagramCertificateSigned>>(
                "cert",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.cert },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.cert },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "identity_string",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.identity_string },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.identity_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "legacy_server_steam_id",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.legacy_server_steam_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.legacy_server_steam_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages_certs::CMsgSteamNetworkingIdentityLegacyBinary>>(
                "legacy_identity_binary",
                |m: &CMsgSteamSockets_UDP_ConnectOK| { &m.legacy_identity_binary },
                |m: &mut CMsgSteamSockets_UDP_ConnectOK| { &mut m.legacy_identity_binary },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_ConnectOK>(
                "CMsgSteamSockets_UDP_ConnectOK",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_ConnectOK {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_ConnectOK> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_ConnectOK::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_ConnectOK {
    fn clear(&mut self) {
        self.client_connection_id = ::std::option::Option::None;
        self.server_connection_id = ::std::option::Option::None;
        self.your_timestamp = ::std::option::Option::None;
        self.delay_time_usec = ::std::option::Option::None;
        self.crypt.clear();
        self.cert.clear();
        self.identity_string.clear();
        self.legacy_server_steam_id = ::std::option::Option::None;
        self.legacy_identity_binary.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_ConnectOK {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_ConnectOK {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_ConnectionClosed {
    // message fields
    to_connection_id: ::std::option::Option<u32>,
    from_connection_id: ::std::option::Option<u32>,
    debug: ::protobuf::SingularField<::std::string::String>,
    reason_code: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_ConnectionClosed {
    fn default() -> &'a CMsgSteamSockets_UDP_ConnectionClosed {
        <CMsgSteamSockets_UDP_ConnectionClosed as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_ConnectionClosed {
    pub fn new() -> CMsgSteamSockets_UDP_ConnectionClosed {
        ::std::default::Default::default()
    }

    // optional fixed32 to_connection_id = 4;


    pub fn get_to_connection_id(&self) -> u32 {
        self.to_connection_id.unwrap_or(0)
    }
    pub fn clear_to_connection_id(&mut self) {
        self.to_connection_id = ::std::option::Option::None;
    }

    pub fn has_to_connection_id(&self) -> bool {
        self.to_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_to_connection_id(&mut self, v: u32) {
        self.to_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 from_connection_id = 5;


    pub fn get_from_connection_id(&self) -> u32 {
        self.from_connection_id.unwrap_or(0)
    }
    pub fn clear_from_connection_id(&mut self) {
        self.from_connection_id = ::std::option::Option::None;
    }

    pub fn has_from_connection_id(&self) -> bool {
        self.from_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_from_connection_id(&mut self, v: u32) {
        self.from_connection_id = ::std::option::Option::Some(v);
    }

    // optional string debug = 2;


    pub fn get_debug(&self) -> &str {
        match self.debug.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_debug(&mut self) {
        self.debug.clear();
    }

    pub fn has_debug(&self) -> bool {
        self.debug.is_some()
    }

    // Param is passed by value, moved
    pub fn set_debug(&mut self, v: ::std::string::String) {
        self.debug = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_debug(&mut self) -> &mut ::std::string::String {
        if self.debug.is_none() {
            self.debug.set_default();
        }
        self.debug.as_mut().unwrap()
    }

    // Take field
    pub fn take_debug(&mut self) -> ::std::string::String {
        self.debug.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 reason_code = 3;


    pub fn get_reason_code(&self) -> u32 {
        self.reason_code.unwrap_or(0)
    }
    pub fn clear_reason_code(&mut self) {
        self.reason_code = ::std::option::Option::None;
    }

    pub fn has_reason_code(&self) -> bool {
        self.reason_code.is_some()
    }

    // Param is passed by value, moved
    pub fn set_reason_code(&mut self, v: u32) {
        self.reason_code = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_ConnectionClosed {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.to_connection_id = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.from_connection_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.debug)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.reason_code = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.to_connection_id {
            my_size += 5;
        }
        if let Some(v) = self.from_connection_id {
            my_size += 5;
        }
        if let Some(ref v) = self.debug.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.reason_code {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.to_connection_id {
            os.write_fixed32(4, v)?;
        }
        if let Some(v) = self.from_connection_id {
            os.write_fixed32(5, v)?;
        }
        if let Some(ref v) = self.debug.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.reason_code {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_ConnectionClosed {
        CMsgSteamSockets_UDP_ConnectionClosed::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "to_connection_id",
                |m: &CMsgSteamSockets_UDP_ConnectionClosed| { &m.to_connection_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectionClosed| { &mut m.to_connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "from_connection_id",
                |m: &CMsgSteamSockets_UDP_ConnectionClosed| { &m.from_connection_id },
                |m: &mut CMsgSteamSockets_UDP_ConnectionClosed| { &mut m.from_connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "debug",
                |m: &CMsgSteamSockets_UDP_ConnectionClosed| { &m.debug },
                |m: &mut CMsgSteamSockets_UDP_ConnectionClosed| { &mut m.debug },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "reason_code",
                |m: &CMsgSteamSockets_UDP_ConnectionClosed| { &m.reason_code },
                |m: &mut CMsgSteamSockets_UDP_ConnectionClosed| { &mut m.reason_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_ConnectionClosed>(
                "CMsgSteamSockets_UDP_ConnectionClosed",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_ConnectionClosed {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_ConnectionClosed> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_ConnectionClosed::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_ConnectionClosed {
    fn clear(&mut self) {
        self.to_connection_id = ::std::option::Option::None;
        self.from_connection_id = ::std::option::Option::None;
        self.debug.clear();
        self.reason_code = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_ConnectionClosed {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_ConnectionClosed {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_NoConnection {
    // message fields
    from_connection_id: ::std::option::Option<u32>,
    to_connection_id: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_NoConnection {
    fn default() -> &'a CMsgSteamSockets_UDP_NoConnection {
        <CMsgSteamSockets_UDP_NoConnection as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_NoConnection {
    pub fn new() -> CMsgSteamSockets_UDP_NoConnection {
        ::std::default::Default::default()
    }

    // optional fixed32 from_connection_id = 2;


    pub fn get_from_connection_id(&self) -> u32 {
        self.from_connection_id.unwrap_or(0)
    }
    pub fn clear_from_connection_id(&mut self) {
        self.from_connection_id = ::std::option::Option::None;
    }

    pub fn has_from_connection_id(&self) -> bool {
        self.from_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_from_connection_id(&mut self, v: u32) {
        self.from_connection_id = ::std::option::Option::Some(v);
    }

    // optional fixed32 to_connection_id = 3;


    pub fn get_to_connection_id(&self) -> u32 {
        self.to_connection_id.unwrap_or(0)
    }
    pub fn clear_to_connection_id(&mut self) {
        self.to_connection_id = ::std::option::Option::None;
    }

    pub fn has_to_connection_id(&self) -> bool {
        self.to_connection_id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_to_connection_id(&mut self, v: u32) {
        self.to_connection_id = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_NoConnection {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.from_connection_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed32()?;
                    self.to_connection_id = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.from_connection_id {
            my_size += 5;
        }
        if let Some(v) = self.to_connection_id {
            my_size += 5;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.from_connection_id {
            os.write_fixed32(2, v)?;
        }
        if let Some(v) = self.to_connection_id {
            os.write_fixed32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_NoConnection {
        CMsgSteamSockets_UDP_NoConnection::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "from_connection_id",
                |m: &CMsgSteamSockets_UDP_NoConnection| { &m.from_connection_id },
                |m: &mut CMsgSteamSockets_UDP_NoConnection| { &mut m.from_connection_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
                "to_connection_id",
                |m: &CMsgSteamSockets_UDP_NoConnection| { &m.to_connection_id },
                |m: &mut CMsgSteamSockets_UDP_NoConnection| { &mut m.to_connection_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_NoConnection>(
                "CMsgSteamSockets_UDP_NoConnection",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_NoConnection {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_NoConnection> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_NoConnection::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_NoConnection {
    fn clear(&mut self) {
        self.from_connection_id = ::std::option::Option::None;
        self.to_connection_id = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_NoConnection {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_NoConnection {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CMsgSteamSockets_UDP_Stats {
    // message fields
    pub stats: ::protobuf::SingularPtrField<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>,
    flags: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CMsgSteamSockets_UDP_Stats {
    fn default() -> &'a CMsgSteamSockets_UDP_Stats {
        <CMsgSteamSockets_UDP_Stats as ::protobuf::Message>::default_instance()
    }
}

impl CMsgSteamSockets_UDP_Stats {
    pub fn new() -> CMsgSteamSockets_UDP_Stats {
        ::std::default::Default::default()
    }

    // optional .CMsgSteamDatagramConnectionQuality stats = 1;


    pub fn get_stats(&self) -> &super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality {
        self.stats.as_ref().unwrap_or_else(|| <super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality as ::protobuf::Message>::default_instance())
    }
    pub fn clear_stats(&mut self) {
        self.stats.clear();
    }

    pub fn has_stats(&self) -> bool {
        self.stats.is_some()
    }

    // Param is passed by value, moved
    pub fn set_stats(&mut self, v: super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality) {
        self.stats = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_stats(&mut self) -> &mut super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality {
        if self.stats.is_none() {
            self.stats.set_default();
        }
        self.stats.as_mut().unwrap()
    }

    // Take field
    pub fn take_stats(&mut self) -> super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality {
        self.stats.take().unwrap_or_else(|| super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality::new())
    }

    // optional uint32 flags = 3;


    pub fn get_flags(&self) -> u32 {
        self.flags.unwrap_or(0)
    }
    pub fn clear_flags(&mut self) {
        self.flags = ::std::option::Option::None;
    }

    pub fn has_flags(&self) -> bool {
        self.flags.is_some()
    }

    // Param is passed by value, moved
    pub fn set_flags(&mut self, v: u32) {
        self.flags = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for CMsgSteamSockets_UDP_Stats {
    fn is_initialized(&self) -> bool {
        for v in &self.stats {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stats)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.flags = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(v) = self.flags {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.stats.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(v) = self.flags {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CMsgSteamSockets_UDP_Stats {
        CMsgSteamSockets_UDP_Stats::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steamnetworkingsockets_messages::CMsgSteamDatagramConnectionQuality>>(
                "stats",
                |m: &CMsgSteamSockets_UDP_Stats| { &m.stats },
                |m: &mut CMsgSteamSockets_UDP_Stats| { &mut m.stats },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "flags",
                |m: &CMsgSteamSockets_UDP_Stats| { &m.flags },
                |m: &mut CMsgSteamSockets_UDP_Stats| { &mut m.flags },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgSteamSockets_UDP_Stats>(
                "CMsgSteamSockets_UDP_Stats",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CMsgSteamSockets_UDP_Stats {
        static instance: ::protobuf::rt::LazyV2<CMsgSteamSockets_UDP_Stats> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CMsgSteamSockets_UDP_Stats::new)
    }
}

impl ::protobuf::Clear for CMsgSteamSockets_UDP_Stats {
    fn clear(&mut self) {
        self.stats.clear();
        self.flags = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CMsgSteamSockets_UDP_Stats {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_Stats {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum CMsgSteamSockets_UDP_Stats_Flags {
    ACK_REQUEST_E2E = 2,
    ACK_REQUEST_IMMEDIATE = 4,
    NOT_PRIMARY_TRANSPORT_E2E = 16,
}

impl ::protobuf::ProtobufEnum for CMsgSteamSockets_UDP_Stats_Flags {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<CMsgSteamSockets_UDP_Stats_Flags> {
        match value {
            2 => ::std::option::Option::Some(CMsgSteamSockets_UDP_Stats_Flags::ACK_REQUEST_E2E),
            4 => ::std::option::Option::Some(CMsgSteamSockets_UDP_Stats_Flags::ACK_REQUEST_IMMEDIATE),
            16 => ::std::option::Option::Some(CMsgSteamSockets_UDP_Stats_Flags::NOT_PRIMARY_TRANSPORT_E2E),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [CMsgSteamSockets_UDP_Stats_Flags] = &[
            CMsgSteamSockets_UDP_Stats_Flags::ACK_REQUEST_E2E,
            CMsgSteamSockets_UDP_Stats_Flags::ACK_REQUEST_IMMEDIATE,
            CMsgSteamSockets_UDP_Stats_Flags::NOT_PRIMARY_TRANSPORT_E2E,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<CMsgSteamSockets_UDP_Stats_Flags>("CMsgSteamSockets_UDP_Stats.Flags", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for CMsgSteamSockets_UDP_Stats_Flags {
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for CMsgSteamSockets_UDP_Stats_Flags {
    fn default() -> Self {
        CMsgSteamSockets_UDP_Stats_Flags::ACK_REQUEST_E2E
    }
}

impl ::protobuf::reflect::ProtobufValue for CMsgSteamSockets_UDP_Stats_Flags {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ESteamNetworkingUDPMsgID {
    k_ESteamNetworkingUDPMsg_ChallengeRequest = 32,
    k_ESteamNetworkingUDPMsg_ChallengeReply = 33,
    k_ESteamNetworkingUDPMsg_ConnectRequest = 34,
    k_ESteamNetworkingUDPMsg_ConnectOK = 35,
    k_ESteamNetworkingUDPMsg_ConnectionClosed = 36,
    k_ESteamNetworkingUDPMsg_NoConnection = 37,
}

impl ::protobuf::ProtobufEnum for ESteamNetworkingUDPMsgID {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ESteamNetworkingUDPMsgID> {
        match value {
            32 => ::std::option::Option::Some(ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ChallengeRequest),
            33 => ::std::option::Option::Some(ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ChallengeReply),
            34 => ::std::option::Option::Some(ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ConnectRequest),
            35 => ::std::option::Option::Some(ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ConnectOK),
            36 => ::std::option::Option::Some(ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ConnectionClosed),
            37 => ::std::option::Option::Some(ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_NoConnection),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ESteamNetworkingUDPMsgID] = &[
            ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ChallengeRequest,
            ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ChallengeReply,
            ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ConnectRequest,
            ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ConnectOK,
            ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ConnectionClosed,
            ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_NoConnection,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ESteamNetworkingUDPMsgID>("ESteamNetworkingUDPMsgID", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ESteamNetworkingUDPMsgID {
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for ESteamNetworkingUDPMsgID {
    fn default() -> Self {
        ESteamNetworkingUDPMsgID::k_ESteamNetworkingUDPMsg_ChallengeRequest
    }
}

impl ::protobuf::reflect::ProtobufValue for ESteamNetworkingUDPMsgID {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n)steamnetworkingsockets_messages_udp.proto\x1a+steamnetworkingsockets_\
    messages_certs.proto\x1a%steamnetworkingsockets_messages.proto\"\x9a\x01\
    \n%CMsgSteamSockets_UDP_ChallengeRequest\x12#\n\rconnection_id\x18\x01\
    \x20\x01(\x07R\x0cconnectionId\x12!\n\x0cmy_timestamp\x18\x03\x20\x01(\
    \x06R\x0bmyTimestamp\x12)\n\x10protocol_version\x18\x04\x20\x01(\rR\x0fp\
    rotocolVersion\"\xba\x01\n#CMsgSteamSockets_UDP_ChallengeReply\x12#\n\rc\
    onnection_id\x18\x01\x20\x01(\x07R\x0cconnectionId\x12\x1c\n\tchallenge\
    \x18\x02\x20\x01(\x06R\tchallenge\x12%\n\x0eyour_timestamp\x18\x03\x20\
    \x01(\x06R\ryourTimestamp\x12)\n\x10protocol_version\x18\x04\x20\x01(\rR\
    \x0fprotocolVersion\"\xa7\x04\n#CMsgSteamSockets_UDP_ConnectRequest\x120\
    \n\x14client_connection_id\x18\x01\x20\x01(\x07R\x12clientConnectionId\
    \x12\x1c\n\tchallenge\x18\x02\x20\x01(\x06R\tchallenge\x12!\n\x0cmy_time\
    stamp\x18\x05\x20\x01(\x06R\x0bmyTimestamp\x12\x1e\n\x0bping_est_ms\x18\
    \x06\x20\x01(\rR\tpingEstMs\x12>\n\x05crypt\x18\x07\x20\x01(\x0b2(.CMsgS\
    teamDatagramSessionCryptInfoSignedR\x05crypt\x127\n\x04cert\x18\x04\x20\
    \x01(\x0b2#.CMsgSteamDatagramCertificateSignedR\x04cert\x126\n\x17legacy\
    _protocol_version\x18\x08\x20\x01(\rR\x15legacyProtocolVersion\x12'\n\
    \x0fidentity_string\x18\n\x20\x01(\tR\x0eidentityString\x123\n\x16legacy\
    _client_steam_id\x18\x03\x20\x01(\x06R\x13legacyClientSteamId\x12^\n\x16\
    legacy_identity_binary\x18\t\x20\x01(\x0b2(.CMsgSteamNetworkingIdentityL\
    egacyBinaryR\x14legacyIdentityBinary\"\x8a\x04\n\x1eCMsgSteamSockets_UDP\
    _ConnectOK\x120\n\x14client_connection_id\x18\x01\x20\x01(\x07R\x12clien\
    tConnectionId\x120\n\x14server_connection_id\x18\x05\x20\x01(\x07R\x12se\
    rverConnectionId\x12%\n\x0eyour_timestamp\x18\x03\x20\x01(\x06R\ryourTim\
    estamp\x12&\n\x0fdelay_time_usec\x18\x04\x20\x01(\rR\rdelayTimeUsec\x12>\
    \n\x05crypt\x18\x07\x20\x01(\x0b2(.CMsgSteamDatagramSessionCryptInfoSign\
    edR\x05crypt\x127\n\x04cert\x18\x08\x20\x01(\x0b2#.CMsgSteamDatagramCert\
    ificateSignedR\x04cert\x12'\n\x0fidentity_string\x18\x0b\x20\x01(\tR\x0e\
    identityString\x123\n\x16legacy_server_steam_id\x18\x02\x20\x01(\x06R\
    \x13legacyServerSteamId\x12^\n\x16legacy_identity_binary\x18\n\x20\x01(\
    \x0b2(.CMsgSteamNetworkingIdentityLegacyBinaryR\x14legacyIdentityBinary\
    \"\xb6\x01\n%CMsgSteamSockets_UDP_ConnectionClosed\x12(\n\x10to_connecti\
    on_id\x18\x04\x20\x01(\x07R\x0etoConnectionId\x12,\n\x12from_connection_\
    id\x18\x05\x20\x01(\x07R\x10fromConnectionId\x12\x14\n\x05debug\x18\x02\
    \x20\x01(\tR\x05debug\x12\x1f\n\x0breason_code\x18\x03\x20\x01(\rR\nreas\
    onCode\"{\n!CMsgSteamSockets_UDP_NoConnection\x12,\n\x12from_connection_\
    id\x18\x02\x20\x01(\x07R\x10fromConnectionId\x12(\n\x10to_connection_id\
    \x18\x03\x20\x01(\x07R\x0etoConnectionId\"\xc5\x01\n\x1aCMsgSteamSockets\
    _UDP_Stats\x129\n\x05stats\x18\x01\x20\x01(\x0b2#.CMsgSteamDatagramConne\
    ctionQualityR\x05stats\x12\x14\n\x05flags\x18\x03\x20\x01(\rR\x05flags\"\
    V\n\x05Flags\x12\x13\n\x0fACK_REQUEST_E2E\x10\x02\x12\x19\n\x15ACK_REQUE\
    ST_IMMEDIATE\x10\x04\x12\x1d\n\x19NOT_PRIMARY_TRANSPORT_E2E\x10\x10*\xa5\
    \x02\n\x18ESteamNetworkingUDPMsgID\x12-\n)k_ESteamNetworkingUDPMsg_Chall\
    engeRequest\x10\x20\x12+\n'k_ESteamNetworkingUDPMsg_ChallengeReply\x10!\
    \x12+\n'k_ESteamNetworkingUDPMsg_ConnectRequest\x10\"\x12&\n\"k_ESteamNe\
    tworkingUDPMsg_ConnectOK\x10#\x12-\n)k_ESteamNetworkingUDPMsg_Connection\
    Closed\x10$\x12)\n%k_ESteamNetworkingUDPMsg_NoConnection\x10%B\x05H\x01\
    \x80\x01\0J\xd1\x17\n\x06\x12\x04\0\0J\x01\n\t\n\x02\x03\0\x12\x03\0\05\
    \n\t\n\x02\x03\x01\x12\x03\x01\0/\n\x08\n\x01\x08\x12\x03\x03\0\x1c\n\t\
    \n\x02\x08\t\x12\x03\x03\0\x1c\n\x08\n\x01\x08\x12\x03\x04\0#\n\t\n\x02\
    \x08\x10\x12\x03\x04\0#\n\n\n\x02\x05\0\x12\x04\x06\0\r\x01\n\n\n\x03\
    \x05\0\x01\x12\x03\x06\x05\x1d\n\x0b\n\x04\x05\0\x02\0\x12\x03\x07\x087\
    \n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x07\x081\n\x0c\n\x05\x05\0\x02\0\
    \x02\x12\x03\x0746\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x08\x085\n\x0c\n\
    \x05\x05\0\x02\x01\x01\x12\x03\x08\x08/\n\x0c\n\x05\x05\0\x02\x01\x02\
    \x12\x03\x0824\n\x0b\n\x04\x05\0\x02\x02\x12\x03\t\x085\n\x0c\n\x05\x05\
    \0\x02\x02\x01\x12\x03\t\x08/\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\t24\
    \n\x0b\n\x04\x05\0\x02\x03\x12\x03\n\x080\n\x0c\n\x05\x05\0\x02\x03\x01\
    \x12\x03\n\x08*\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03\n-/\n\x0b\n\x04\
    \x05\0\x02\x04\x12\x03\x0b\x087\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03\
    \x0b\x081\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03\x0b46\n\x0b\n\x04\x05\0\
    \x02\x05\x12\x03\x0c\x083\n\x0c\n\x05\x05\0\x02\x05\x01\x12\x03\x0c\x08-\
    \n\x0c\n\x05\x05\0\x02\x05\x02\x12\x03\x0c02\n\n\n\x02\x04\0\x12\x04\x0f\
    \0\x13\x01\n\n\n\x03\x04\0\x01\x12\x03\x0f\x08-\n\x0b\n\x04\x04\0\x02\0\
    \x12\x03\x10\x08+\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\x10\x08\x10\n\x0c\
    \n\x05\x04\0\x02\0\x05\x12\x03\x10\x11\x18\n\x0c\n\x05\x04\0\x02\0\x01\
    \x12\x03\x10\x19&\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x10)*\n\x0b\n\x04\
    \x04\0\x02\x01\x12\x03\x11\x08*\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03\
    \x11\x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x11\x11\x18\n\x0c\n\
    \x05\x04\0\x02\x01\x01\x12\x03\x11\x19%\n\x0c\n\x05\x04\0\x02\x01\x03\
    \x12\x03\x11()\n\x0b\n\x04\x04\0\x02\x02\x12\x03\x12\x08-\n\x0c\n\x05\
    \x04\0\x02\x02\x04\x12\x03\x12\x08\x10\n\x0c\n\x05\x04\0\x02\x02\x05\x12\
    \x03\x12\x11\x17\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x12\x18(\n\x0c\n\
    \x05\x04\0\x02\x02\x03\x12\x03\x12+,\n\n\n\x02\x04\x01\x12\x04\x15\0\x1a\
    \x01\n\n\n\x03\x04\x01\x01\x12\x03\x15\x08+\n\x0b\n\x04\x04\x01\x02\0\
    \x12\x03\x16\x08+\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\x16\x08\x10\n\
    \x0c\n\x05\x04\x01\x02\0\x05\x12\x03\x16\x11\x18\n\x0c\n\x05\x04\x01\x02\
    \0\x01\x12\x03\x16\x19&\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x16)*\n\
    \x0b\n\x04\x04\x01\x02\x01\x12\x03\x17\x08'\n\x0c\n\x05\x04\x01\x02\x01\
    \x04\x12\x03\x17\x08\x10\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x17\x11\
    \x18\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x17\x19\"\n\x0c\n\x05\x04\
    \x01\x02\x01\x03\x12\x03\x17%&\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x18\
    \x08,\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03\x18\x08\x10\n\x0c\n\x05\
    \x04\x01\x02\x02\x05\x12\x03\x18\x11\x18\n\x0c\n\x05\x04\x01\x02\x02\x01\
    \x12\x03\x18\x19'\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x18*+\n\x0b\n\
    \x04\x04\x01\x02\x03\x12\x03\x19\x08-\n\x0c\n\x05\x04\x01\x02\x03\x04\
    \x12\x03\x19\x08\x10\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03\x19\x11\x17\
    \n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\x19\x18(\n\x0c\n\x05\x04\x01\
    \x02\x03\x03\x12\x03\x19+,\n\n\n\x02\x04\x02\x12\x04\x1c\0'\x01\n\n\n\
    \x03\x04\x02\x01\x12\x03\x1c\x08+\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x1d\
    \x082\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\x1d\x08\x10\n\x0c\n\x05\x04\
    \x02\x02\0\x05\x12\x03\x1d\x11\x18\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\
    \x1d\x19-\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x1d01\n\x0b\n\x04\x04\
    \x02\x02\x01\x12\x03\x1e\x08'\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03\
    \x1e\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03\x1e\x11\x18\n\x0c\n\
    \x05\x04\x02\x02\x01\x01\x12\x03\x1e\x19\"\n\x0c\n\x05\x04\x02\x02\x01\
    \x03\x12\x03\x1e%&\n\x0b\n\x04\x04\x02\x02\x02\x12\x03\x1f\x08*\n\x0c\n\
    \x05\x04\x02\x02\x02\x04\x12\x03\x1f\x08\x10\n\x0c\n\x05\x04\x02\x02\x02\
    \x05\x12\x03\x1f\x11\x18\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03\x1f\x19\
    %\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03\x1f()\n\x0b\n\x04\x04\x02\x02\
    \x03\x12\x03\x20\x08(\n\x0c\n\x05\x04\x02\x02\x03\x04\x12\x03\x20\x08\
    \x10\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x03\x20\x11\x17\n\x0c\n\x05\x04\
    \x02\x02\x03\x01\x12\x03\x20\x18#\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\
    \x03\x20&'\n\x0b\n\x04\x04\x02\x02\x04\x12\x03!\x08D\n\x0c\n\x05\x04\x02\
    \x02\x04\x04\x12\x03!\x08\x10\n\x0c\n\x05\x04\x02\x02\x04\x06\x12\x03!\
    \x119\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03!:?\n\x0c\n\x05\x04\x02\x02\
    \x04\x03\x12\x03!BC\n\x0b\n\x04\x04\x02\x02\x05\x12\x03\"\x08>\n\x0c\n\
    \x05\x04\x02\x02\x05\x04\x12\x03\"\x08\x10\n\x0c\n\x05\x04\x02\x02\x05\
    \x06\x12\x03\"\x114\n\x0c\n\x05\x04\x02\x02\x05\x01\x12\x03\"59\n\x0c\n\
    \x05\x04\x02\x02\x05\x03\x12\x03\"<=\n\x0b\n\x04\x04\x02\x02\x06\x12\x03\
    #\x084\n\x0c\n\x05\x04\x02\x02\x06\x04\x12\x03#\x08\x10\n\x0c\n\x05\x04\
    \x02\x02\x06\x05\x12\x03#\x11\x17\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\
    \x03#\x18/\n\x0c\n\x05\x04\x02\x02\x06\x03\x12\x03#23\n\x0b\n\x04\x04\
    \x02\x02\x07\x12\x03$\x08-\n\x0c\n\x05\x04\x02\x02\x07\x04\x12\x03$\x08\
    \x10\n\x0c\n\x05\x04\x02\x02\x07\x05\x12\x03$\x11\x17\n\x0c\n\x05\x04\
    \x02\x02\x07\x01\x12\x03$\x18'\n\x0c\n\x05\x04\x02\x02\x07\x03\x12\x03$*\
    ,\n\x0b\n\x04\x04\x02\x02\x08\x12\x03%\x084\n\x0c\n\x05\x04\x02\x02\x08\
    \x04\x12\x03%\x08\x10\n\x0c\n\x05\x04\x02\x02\x08\x05\x12\x03%\x11\x18\n\
    \x0c\n\x05\x04\x02\x02\x08\x01\x12\x03%\x19/\n\x0c\n\x05\x04\x02\x02\x08\
    \x03\x12\x03%23\n\x0b\n\x04\x04\x02\x02\t\x12\x03&\x08U\n\x0c\n\x05\x04\
    \x02\x02\t\x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x02\x02\t\x06\x12\x03&\
    \x119\n\x0c\n\x05\x04\x02\x02\t\x01\x12\x03&:P\n\x0c\n\x05\x04\x02\x02\t\
    \x03\x12\x03&ST\n\n\n\x02\x04\x03\x12\x04)\03\x01\n\n\n\x03\x04\x03\x01\
    \x12\x03)\x08&\n\x0b\n\x04\x04\x03\x02\0\x12\x03*\x082\n\x0c\n\x05\x04\
    \x03\x02\0\x04\x12\x03*\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03*\
    \x11\x18\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03*\x19-\n\x0c\n\x05\x04\x03\
    \x02\0\x03\x12\x03*01\n\x0b\n\x04\x04\x03\x02\x01\x12\x03+\x082\n\x0c\n\
    \x05\x04\x03\x02\x01\x04\x12\x03+\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\
    \x05\x12\x03+\x11\x18\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03+\x19-\n\
    \x0c\n\x05\x04\x03\x02\x01\x03\x12\x03+01\n\x0b\n\x04\x04\x03\x02\x02\
    \x12\x03,\x08,\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03,\x08\x10\n\x0c\n\
    \x05\x04\x03\x02\x02\x05\x12\x03,\x11\x18\n\x0c\n\x05\x04\x03\x02\x02\
    \x01\x12\x03,\x19'\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03,*+\n\x0b\n\
    \x04\x04\x03\x02\x03\x12\x03-\x08,\n\x0c\n\x05\x04\x03\x02\x03\x04\x12\
    \x03-\x08\x10\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\x03-\x11\x17\n\x0c\n\
    \x05\x04\x03\x02\x03\x01\x12\x03-\x18'\n\x0c\n\x05\x04\x03\x02\x03\x03\
    \x12\x03-*+\n\x0b\n\x04\x04\x03\x02\x04\x12\x03.\x08D\n\x0c\n\x05\x04\
    \x03\x02\x04\x04\x12\x03.\x08\x10\n\x0c\n\x05\x04\x03\x02\x04\x06\x12\
    \x03.\x119\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03.:?\n\x0c\n\x05\x04\
    \x03\x02\x04\x03\x12\x03.BC\n\x0b\n\x04\x04\x03\x02\x05\x12\x03/\x08>\n\
    \x0c\n\x05\x04\x03\x02\x05\x04\x12\x03/\x08\x10\n\x0c\n\x05\x04\x03\x02\
    \x05\x06\x12\x03/\x114\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x03/59\n\x0c\
    \n\x05\x04\x03\x02\x05\x03\x12\x03/<=\n\x0b\n\x04\x04\x03\x02\x06\x12\
    \x030\x08-\n\x0c\n\x05\x04\x03\x02\x06\x04\x12\x030\x08\x10\n\x0c\n\x05\
    \x04\x03\x02\x06\x05\x12\x030\x11\x17\n\x0c\n\x05\x04\x03\x02\x06\x01\
    \x12\x030\x18'\n\x0c\n\x05\x04\x03\x02\x06\x03\x12\x030*,\n\x0b\n\x04\
    \x04\x03\x02\x07\x12\x031\x084\n\x0c\n\x05\x04\x03\x02\x07\x04\x12\x031\
    \x08\x10\n\x0c\n\x05\x04\x03\x02\x07\x05\x12\x031\x11\x18\n\x0c\n\x05\
    \x04\x03\x02\x07\x01\x12\x031\x19/\n\x0c\n\x05\x04\x03\x02\x07\x03\x12\
    \x03123\n\x0b\n\x04\x04\x03\x02\x08\x12\x032\x08V\n\x0c\n\x05\x04\x03\
    \x02\x08\x04\x12\x032\x08\x10\n\x0c\n\x05\x04\x03\x02\x08\x06\x12\x032\
    \x119\n\x0c\n\x05\x04\x03\x02\x08\x01\x12\x032:P\n\x0c\n\x05\x04\x03\x02\
    \x08\x03\x12\x032SU\n\n\n\x02\x04\x04\x12\x045\0:\x01\n\n\n\x03\x04\x04\
    \x01\x12\x035\x08-\n\x0b\n\x04\x04\x04\x02\0\x12\x036\x08.\n\x0c\n\x05\
    \x04\x04\x02\0\x04\x12\x036\x08\x10\n\x0c\n\x05\x04\x04\x02\0\x05\x12\
    \x036\x11\x18\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x036\x19)\n\x0c\n\x05\
    \x04\x04\x02\0\x03\x12\x036,-\n\x0b\n\x04\x04\x04\x02\x01\x12\x037\x080\
    \n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x037\x08\x10\n\x0c\n\x05\x04\x04\
    \x02\x01\x05\x12\x037\x11\x18\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x037\
    \x19+\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x037./\n\x0b\n\x04\x04\x04\x02\
    \x02\x12\x038\x08\"\n\x0c\n\x05\x04\x04\x02\x02\x04\x12\x038\x08\x10\n\
    \x0c\n\x05\x04\x04\x02\x02\x05\x12\x038\x11\x17\n\x0c\n\x05\x04\x04\x02\
    \x02\x01\x12\x038\x18\x1d\n\x0c\n\x05\x04\x04\x02\x02\x03\x12\x038\x20!\
    \n\x0b\n\x04\x04\x04\x02\x03\x12\x039\x08(\n\x0c\n\x05\x04\x04\x02\x03\
    \x04\x12\x039\x08\x10\n\x0c\n\x05\x04\x04\x02\x03\x05\x12\x039\x11\x17\n\
    \x0c\n\x05\x04\x04\x02\x03\x01\x12\x039\x18#\n\x0c\n\x05\x04\x04\x02\x03\
    \x03\x12\x039&'\n\n\n\x02\x04\x05\x12\x04<\0?\x01\n\n\n\x03\x04\x05\x01\
    \x12\x03<\x08)\n\x0b\n\x04\x04\x05\x02\0\x12\x03=\x080\n\x0c\n\x05\x04\
    \x05\x02\0\x04\x12\x03=\x08\x10\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03=\
    \x11\x18\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03=\x19+\n\x0c\n\x05\x04\x05\
    \x02\0\x03\x12\x03=./\n\x0b\n\x04\x04\x05\x02\x01\x12\x03>\x08.\n\x0c\n\
    \x05\x04\x05\x02\x01\x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\x05\x02\x01\
    \x05\x12\x03>\x11\x18\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03>\x19)\n\
    \x0c\n\x05\x04\x05\x02\x01\x03\x12\x03>,-\n\n\n\x02\x04\x06\x12\x04A\0J\
    \x01\n\n\n\x03\x04\x06\x01\x12\x03A\x08\"\n\x0c\n\x04\x04\x06\x04\0\x12\
    \x04B\x08F\t\n\x0c\n\x05\x04\x06\x04\0\x01\x12\x03B\r\x12\n\r\n\x06\x04\
    \x06\x04\0\x02\0\x12\x03C\x10$\n\x0e\n\x07\x04\x06\x04\0\x02\0\x01\x12\
    \x03C\x10\x1f\n\x0e\n\x07\x04\x06\x04\0\x02\0\x02\x12\x03C\"#\n\r\n\x06\
    \x04\x06\x04\0\x02\x01\x12\x03D\x10*\n\x0e\n\x07\x04\x06\x04\0\x02\x01\
    \x01\x12\x03D\x10%\n\x0e\n\x07\x04\x06\x04\0\x02\x01\x02\x12\x03D()\n\r\
    \n\x06\x04\x06\x04\0\x02\x02\x12\x03E\x10/\n\x0e\n\x07\x04\x06\x04\0\x02\
    \x02\x01\x12\x03E\x10)\n\x0e\n\x07\x04\x06\x04\0\x02\x02\x02\x12\x03E,.\
    \n\x0b\n\x04\x04\x06\x02\0\x12\x03H\x08?\n\x0c\n\x05\x04\x06\x02\0\x04\
    \x12\x03H\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x06\x12\x03H\x114\n\x0c\n\
    \x05\x04\x06\x02\0\x01\x12\x03H5:\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03H\
    =>\n\x0b\n\x04\x04\x06\x02\x01\x12\x03I\x08\"\n\x0c\n\x05\x04\x06\x02\
    \x01\x04\x12\x03I\x08\x10\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03I\x11\
    \x17\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03I\x18\x1d\n\x0c\n\x05\x04\
    \x06\x02\x01\x03\x12\x03I\x20!\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}