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 `steammessages_remoteclient.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 CMsgRemoteClientStatus {
    // message fields
    client_id: ::std::option::Option<u64>,
    instance_id: ::std::option::Option<u64>,
    pub status: ::protobuf::SingularPtrField<super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint64 client_id = 1;


    pub fn get_client_id(&self) -> u64 {
        self.client_id.unwrap_or(0)
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = ::std::option::Option::None;
    }

    pub fn has_client_id(&self) -> bool {
        self.client_id.is_some()
    }

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

    // optional uint64 instance_id = 2;


    pub fn get_instance_id(&self) -> u64 {
        self.instance_id.unwrap_or(0)
    }
    pub fn clear_instance_id(&mut self) {
        self.instance_id = ::std::option::Option::None;
    }

    pub fn has_instance_id(&self) -> bool {
        self.instance_id.is_some()
    }

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

    // optional .CMsgRemoteClientBroadcastStatus status = 3;


    pub fn get_status(&self) -> &super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus {
        self.status.as_ref().unwrap_or_else(|| <super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus as ::protobuf::Message>::default_instance())
    }
    pub fn clear_status(&mut self) {
        self.status.clear();
    }

    pub fn has_status(&self) -> bool {
        self.status.is_some()
    }

    // Param is passed by value, moved
    pub fn set_status(&mut self, v: super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus) {
        self.status = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_status(&mut self) -> super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus {
        self.status.take().unwrap_or_else(|| super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus::new())
    }
}

impl ::protobuf::Message for CMsgRemoteClientStatus {
    fn is_initialized(&self) -> bool {
        for v in &self.status {
            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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.instance_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.status)?;
                },
                _ => {
                    ::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_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.instance_id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.status.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_id {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.instance_id {
            os.write_uint64(2, v)?;
        }
        if let Some(ref v) = self.status.as_ref() {
            os.write_tag(3, ::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() -> CMsgRemoteClientStatus {
        CMsgRemoteClientStatus::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::ProtobufTypeUint64>(
                "client_id",
                |m: &CMsgRemoteClientStatus| { &m.client_id },
                |m: &mut CMsgRemoteClientStatus| { &mut m.client_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "instance_id",
                |m: &CMsgRemoteClientStatus| { &m.instance_id },
                |m: &mut CMsgRemoteClientStatus| { &mut m.instance_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus>>(
                "status",
                |m: &CMsgRemoteClientStatus| { &m.status },
                |m: &mut CMsgRemoteClientStatus| { &mut m.status },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientStatus>(
                "CMsgRemoteClientStatus",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientStatus {
    fn clear(&mut self) {
        self.client_id = ::std::option::Option::None;
        self.instance_id = ::std::option::Option::None;
        self.status.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientAppStatus {
    // message fields
    pub status_updates: ::protobuf::RepeatedField<CMsgRemoteClientAppStatus_AppStatus>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CMsgRemoteClientAppStatus.AppStatus status_updates = 1;


    pub fn get_status_updates(&self) -> &[CMsgRemoteClientAppStatus_AppStatus] {
        &self.status_updates
    }
    pub fn clear_status_updates(&mut self) {
        self.status_updates.clear();
    }

    // Param is passed by value, moved
    pub fn set_status_updates(&mut self, v: ::protobuf::RepeatedField<CMsgRemoteClientAppStatus_AppStatus>) {
        self.status_updates = v;
    }

    // Mutable pointer to the field.
    pub fn mut_status_updates(&mut self) -> &mut ::protobuf::RepeatedField<CMsgRemoteClientAppStatus_AppStatus> {
        &mut self.status_updates
    }

    // Take field
    pub fn take_status_updates(&mut self) -> ::protobuf::RepeatedField<CMsgRemoteClientAppStatus_AppStatus> {
        ::std::mem::replace(&mut self.status_updates, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CMsgRemoteClientAppStatus {
    fn is_initialized(&self) -> bool {
        for v in &self.status_updates {
            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_repeated_message_into(wire_type, is, &mut self.status_updates)?;
                },
                _ => {
                    ::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;
        for value in &self.status_updates {
            let len = value.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<()> {
        for v in &self.status_updates {
            os.write_tag(1, ::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() -> CMsgRemoteClientAppStatus {
        CMsgRemoteClientAppStatus::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_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CMsgRemoteClientAppStatus_AppStatus>>(
                "status_updates",
                |m: &CMsgRemoteClientAppStatus| { &m.status_updates },
                |m: &mut CMsgRemoteClientAppStatus| { &mut m.status_updates },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientAppStatus>(
                "CMsgRemoteClientAppStatus",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientAppStatus {
    fn clear(&mut self) {
        self.status_updates.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientAppStatus_AppUpdateInfo {
    // message fields
    time_update_start: ::std::option::Option<u32>,
    bytes_to_download: ::std::option::Option<u64>,
    bytes_downloaded: ::std::option::Option<u64>,
    bytes_to_process: ::std::option::Option<u64>,
    bytes_processed: ::std::option::Option<u64>,
    estimated_seconds_remaining: ::std::option::Option<i32>,
    update_result: ::std::option::Option<i32>,
    update_state: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed32 time_update_start = 1;


    pub fn get_time_update_start(&self) -> u32 {
        self.time_update_start.unwrap_or(0)
    }
    pub fn clear_time_update_start(&mut self) {
        self.time_update_start = ::std::option::Option::None;
    }

    pub fn has_time_update_start(&self) -> bool {
        self.time_update_start.is_some()
    }

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

    // optional uint64 bytes_to_download = 2;


    pub fn get_bytes_to_download(&self) -> u64 {
        self.bytes_to_download.unwrap_or(0)
    }
    pub fn clear_bytes_to_download(&mut self) {
        self.bytes_to_download = ::std::option::Option::None;
    }

    pub fn has_bytes_to_download(&self) -> bool {
        self.bytes_to_download.is_some()
    }

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

    // optional uint64 bytes_downloaded = 3;


    pub fn get_bytes_downloaded(&self) -> u64 {
        self.bytes_downloaded.unwrap_or(0)
    }
    pub fn clear_bytes_downloaded(&mut self) {
        self.bytes_downloaded = ::std::option::Option::None;
    }

    pub fn has_bytes_downloaded(&self) -> bool {
        self.bytes_downloaded.is_some()
    }

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

    // optional uint64 bytes_to_process = 4;


    pub fn get_bytes_to_process(&self) -> u64 {
        self.bytes_to_process.unwrap_or(0)
    }
    pub fn clear_bytes_to_process(&mut self) {
        self.bytes_to_process = ::std::option::Option::None;
    }

    pub fn has_bytes_to_process(&self) -> bool {
        self.bytes_to_process.is_some()
    }

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

    // optional uint64 bytes_processed = 5;


    pub fn get_bytes_processed(&self) -> u64 {
        self.bytes_processed.unwrap_or(0)
    }
    pub fn clear_bytes_processed(&mut self) {
        self.bytes_processed = ::std::option::Option::None;
    }

    pub fn has_bytes_processed(&self) -> bool {
        self.bytes_processed.is_some()
    }

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

    // optional int32 estimated_seconds_remaining = 6;


    pub fn get_estimated_seconds_remaining(&self) -> i32 {
        self.estimated_seconds_remaining.unwrap_or(-1i32)
    }
    pub fn clear_estimated_seconds_remaining(&mut self) {
        self.estimated_seconds_remaining = ::std::option::Option::None;
    }

    pub fn has_estimated_seconds_remaining(&self) -> bool {
        self.estimated_seconds_remaining.is_some()
    }

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

    // optional int32 update_result = 7;


    pub fn get_update_result(&self) -> i32 {
        self.update_result.unwrap_or(0)
    }
    pub fn clear_update_result(&mut self) {
        self.update_result = ::std::option::Option::None;
    }

    pub fn has_update_result(&self) -> bool {
        self.update_result.is_some()
    }

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

    // optional uint32 update_state = 8;


    pub fn get_update_state(&self) -> u32 {
        self.update_state.unwrap_or(0)
    }
    pub fn clear_update_state(&mut self) {
        self.update_state = ::std::option::Option::None;
    }

    pub fn has_update_state(&self) -> bool {
        self.update_state.is_some()
    }

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

impl ::protobuf::Message for CMsgRemoteClientAppStatus_AppUpdateInfo {
    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.time_update_start = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.bytes_to_download = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.bytes_downloaded = ::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_uint64()?;
                    self.bytes_to_process = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.bytes_processed = ::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_int32()?;
                    self.estimated_seconds_remaining = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.update_result = ::std::option::Option::Some(tmp);
                },
                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.update_state = ::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.time_update_start {
            my_size += 5;
        }
        if let Some(v) = self.bytes_to_download {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.bytes_downloaded {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.bytes_to_process {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.bytes_processed {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.estimated_seconds_remaining {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.update_result {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.update_state {
            my_size += ::protobuf::rt::value_size(8, 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.time_update_start {
            os.write_fixed32(1, v)?;
        }
        if let Some(v) = self.bytes_to_download {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.bytes_downloaded {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.bytes_to_process {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.bytes_processed {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.estimated_seconds_remaining {
            os.write_int32(6, v)?;
        }
        if let Some(v) = self.update_result {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.update_state {
            os.write_uint32(8, 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() -> CMsgRemoteClientAppStatus_AppUpdateInfo {
        CMsgRemoteClientAppStatus_AppUpdateInfo::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>(
                "time_update_start",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.time_update_start },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.time_update_start },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "bytes_to_download",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.bytes_to_download },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.bytes_to_download },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "bytes_downloaded",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.bytes_downloaded },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.bytes_downloaded },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "bytes_to_process",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.bytes_to_process },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.bytes_to_process },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "bytes_processed",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.bytes_processed },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.bytes_processed },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "estimated_seconds_remaining",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.estimated_seconds_remaining },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.estimated_seconds_remaining },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "update_result",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.update_result },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.update_result },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "update_state",
                |m: &CMsgRemoteClientAppStatus_AppUpdateInfo| { &m.update_state },
                |m: &mut CMsgRemoteClientAppStatus_AppUpdateInfo| { &mut m.update_state },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientAppStatus_AppUpdateInfo>(
                "CMsgRemoteClientAppStatus.AppUpdateInfo",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientAppStatus_AppUpdateInfo {
    fn clear(&mut self) {
        self.time_update_start = ::std::option::Option::None;
        self.bytes_to_download = ::std::option::Option::None;
        self.bytes_downloaded = ::std::option::Option::None;
        self.bytes_to_process = ::std::option::Option::None;
        self.bytes_processed = ::std::option::Option::None;
        self.estimated_seconds_remaining = ::std::option::Option::None;
        self.update_result = ::std::option::Option::None;
        self.update_state = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientAppStatus_ShortcutInfo {
    // message fields
    name: ::protobuf::SingularField<::std::string::String>,
    icon: ::protobuf::SingularField<::std::string::String>,
    pub categories: ::protobuf::RepeatedField<::std::string::String>,
    exepath: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string name = 1;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

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

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

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

    // optional string icon = 2;


    pub fn get_icon(&self) -> &str {
        match self.icon.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_icon(&mut self) {
        self.icon.clear();
    }

    pub fn has_icon(&self) -> bool {
        self.icon.is_some()
    }

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

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

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

    // repeated string categories = 3;


    pub fn get_categories(&self) -> &[::std::string::String] {
        &self.categories
    }
    pub fn clear_categories(&mut self) {
        self.categories.clear();
    }

    // Param is passed by value, moved
    pub fn set_categories(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.categories = v;
    }

    // Mutable pointer to the field.
    pub fn mut_categories(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.categories
    }

    // Take field
    pub fn take_categories(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.categories, ::protobuf::RepeatedField::new())
    }

    // optional string exepath = 4;


    pub fn get_exepath(&self) -> &str {
        match self.exepath.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_exepath(&mut self) {
        self.exepath.clear();
    }

    pub fn has_exepath(&self) -> bool {
        self.exepath.is_some()
    }

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

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

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

impl ::protobuf::Message for CMsgRemoteClientAppStatus_ShortcutInfo {
    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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.icon)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.categories)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.exepath)?;
                },
                _ => {
                    ::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.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.icon.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        for value in &self.categories {
            my_size += ::protobuf::rt::string_size(3, &value);
        };
        if let Some(ref v) = self.exepath.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        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.name.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.icon.as_ref() {
            os.write_string(2, &v)?;
        }
        for v in &self.categories {
            os.write_string(3, &v)?;
        };
        if let Some(ref v) = self.exepath.as_ref() {
            os.write_string(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() -> CMsgRemoteClientAppStatus_ShortcutInfo {
        CMsgRemoteClientAppStatus_ShortcutInfo::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_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CMsgRemoteClientAppStatus_ShortcutInfo| { &m.name },
                |m: &mut CMsgRemoteClientAppStatus_ShortcutInfo| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "icon",
                |m: &CMsgRemoteClientAppStatus_ShortcutInfo| { &m.icon },
                |m: &mut CMsgRemoteClientAppStatus_ShortcutInfo| { &mut m.icon },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "categories",
                |m: &CMsgRemoteClientAppStatus_ShortcutInfo| { &m.categories },
                |m: &mut CMsgRemoteClientAppStatus_ShortcutInfo| { &mut m.categories },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "exepath",
                |m: &CMsgRemoteClientAppStatus_ShortcutInfo| { &m.exepath },
                |m: &mut CMsgRemoteClientAppStatus_ShortcutInfo| { &mut m.exepath },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientAppStatus_ShortcutInfo>(
                "CMsgRemoteClientAppStatus.ShortcutInfo",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientAppStatus_ShortcutInfo {
    fn clear(&mut self) {
        self.name.clear();
        self.icon.clear();
        self.categories.clear();
        self.exepath.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientAppStatus_AppStatus {
    // message fields
    app_id: ::std::option::Option<u32>,
    app_state: ::std::option::Option<u32>,
    pub update_info: ::protobuf::SingularPtrField<CMsgRemoteClientAppStatus_AppUpdateInfo>,
    pub shortcut_info: ::protobuf::SingularPtrField<CMsgRemoteClientAppStatus_ShortcutInfo>,
    launch_available: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 app_id = 1;


    pub fn get_app_id(&self) -> u32 {
        self.app_id.unwrap_or(0)
    }
    pub fn clear_app_id(&mut self) {
        self.app_id = ::std::option::Option::None;
    }

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional uint32 app_state = 2;


    pub fn get_app_state(&self) -> u32 {
        self.app_state.unwrap_or(0)
    }
    pub fn clear_app_state(&mut self) {
        self.app_state = ::std::option::Option::None;
    }

    pub fn has_app_state(&self) -> bool {
        self.app_state.is_some()
    }

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

    // optional .CMsgRemoteClientAppStatus.AppUpdateInfo update_info = 3;


    pub fn get_update_info(&self) -> &CMsgRemoteClientAppStatus_AppUpdateInfo {
        self.update_info.as_ref().unwrap_or_else(|| <CMsgRemoteClientAppStatus_AppUpdateInfo as ::protobuf::Message>::default_instance())
    }
    pub fn clear_update_info(&mut self) {
        self.update_info.clear();
    }

    pub fn has_update_info(&self) -> bool {
        self.update_info.is_some()
    }

    // Param is passed by value, moved
    pub fn set_update_info(&mut self, v: CMsgRemoteClientAppStatus_AppUpdateInfo) {
        self.update_info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_update_info(&mut self) -> &mut CMsgRemoteClientAppStatus_AppUpdateInfo {
        if self.update_info.is_none() {
            self.update_info.set_default();
        }
        self.update_info.as_mut().unwrap()
    }

    // Take field
    pub fn take_update_info(&mut self) -> CMsgRemoteClientAppStatus_AppUpdateInfo {
        self.update_info.take().unwrap_or_else(|| CMsgRemoteClientAppStatus_AppUpdateInfo::new())
    }

    // optional .CMsgRemoteClientAppStatus.ShortcutInfo shortcut_info = 4;


    pub fn get_shortcut_info(&self) -> &CMsgRemoteClientAppStatus_ShortcutInfo {
        self.shortcut_info.as_ref().unwrap_or_else(|| <CMsgRemoteClientAppStatus_ShortcutInfo as ::protobuf::Message>::default_instance())
    }
    pub fn clear_shortcut_info(&mut self) {
        self.shortcut_info.clear();
    }

    pub fn has_shortcut_info(&self) -> bool {
        self.shortcut_info.is_some()
    }

    // Param is passed by value, moved
    pub fn set_shortcut_info(&mut self, v: CMsgRemoteClientAppStatus_ShortcutInfo) {
        self.shortcut_info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_shortcut_info(&mut self) -> &mut CMsgRemoteClientAppStatus_ShortcutInfo {
        if self.shortcut_info.is_none() {
            self.shortcut_info.set_default();
        }
        self.shortcut_info.as_mut().unwrap()
    }

    // Take field
    pub fn take_shortcut_info(&mut self) -> CMsgRemoteClientAppStatus_ShortcutInfo {
        self.shortcut_info.take().unwrap_or_else(|| CMsgRemoteClientAppStatus_ShortcutInfo::new())
    }

    // optional bool launch_available = 5;


    pub fn get_launch_available(&self) -> bool {
        self.launch_available.unwrap_or(true)
    }
    pub fn clear_launch_available(&mut self) {
        self.launch_available = ::std::option::Option::None;
    }

    pub fn has_launch_available(&self) -> bool {
        self.launch_available.is_some()
    }

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

impl ::protobuf::Message for CMsgRemoteClientAppStatus_AppStatus {
    fn is_initialized(&self) -> bool {
        for v in &self.update_info {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.shortcut_info {
            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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.app_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    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.app_state = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_info)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shortcut_info)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.launch_available = ::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.app_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.app_state {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.update_info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.shortcut_info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(v) = self.launch_available {
            my_size += 2;
        }
        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.app_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.app_state {
            os.write_uint32(2, v)?;
        }
        if let Some(ref v) = self.update_info.as_ref() {
            os.write_tag(3, ::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.shortcut_info.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.launch_available {
            os.write_bool(5, 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() -> CMsgRemoteClientAppStatus_AppStatus {
        CMsgRemoteClientAppStatus_AppStatus::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::ProtobufTypeUint32>(
                "app_id",
                |m: &CMsgRemoteClientAppStatus_AppStatus| { &m.app_id },
                |m: &mut CMsgRemoteClientAppStatus_AppStatus| { &mut m.app_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "app_state",
                |m: &CMsgRemoteClientAppStatus_AppStatus| { &m.app_state },
                |m: &mut CMsgRemoteClientAppStatus_AppStatus| { &mut m.app_state },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CMsgRemoteClientAppStatus_AppUpdateInfo>>(
                "update_info",
                |m: &CMsgRemoteClientAppStatus_AppStatus| { &m.update_info },
                |m: &mut CMsgRemoteClientAppStatus_AppStatus| { &mut m.update_info },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CMsgRemoteClientAppStatus_ShortcutInfo>>(
                "shortcut_info",
                |m: &CMsgRemoteClientAppStatus_AppStatus| { &m.shortcut_info },
                |m: &mut CMsgRemoteClientAppStatus_AppStatus| { &mut m.shortcut_info },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "launch_available",
                |m: &CMsgRemoteClientAppStatus_AppStatus| { &m.launch_available },
                |m: &mut CMsgRemoteClientAppStatus_AppStatus| { &mut m.launch_available },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientAppStatus_AppStatus>(
                "CMsgRemoteClientAppStatus.AppStatus",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientAppStatus_AppStatus {
    fn clear(&mut self) {
        self.app_id = ::std::option::Option::None;
        self.app_state = ::std::option::Option::None;
        self.update_info.clear();
        self.shortcut_info.clear();
        self.launch_available = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientStartStream {
    // message fields
    app_id: ::std::option::Option<u32>,
    environment: ::std::option::Option<i32>,
    gamepad_count: ::std::option::Option<i32>,
    launch_option: ::std::option::Option<i32>,
    lock_parental_lock: ::std::option::Option<bool>,
    unlock_parental_lock: ::protobuf::SingularField<::std::string::String>,
    maximum_resolution_x: ::std::option::Option<i32>,
    maximum_resolution_y: ::std::option::Option<i32>,
    pub gamepads: ::protobuf::RepeatedField<CMsgRemoteClientStartStream_ReservedGamepad>,
    audio_channel_count: ::std::option::Option<i32>,
    pub supported_transport: ::std::vec::Vec<super::steammessages_remoteclient_discovery::EStreamTransport>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 app_id = 1;


    pub fn get_app_id(&self) -> u32 {
        self.app_id.unwrap_or(0)
    }
    pub fn clear_app_id(&mut self) {
        self.app_id = ::std::option::Option::None;
    }

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional int32 environment = 2;


    pub fn get_environment(&self) -> i32 {
        self.environment.unwrap_or(0)
    }
    pub fn clear_environment(&mut self) {
        self.environment = ::std::option::Option::None;
    }

    pub fn has_environment(&self) -> bool {
        self.environment.is_some()
    }

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

    // optional int32 gamepad_count = 3;


    pub fn get_gamepad_count(&self) -> i32 {
        self.gamepad_count.unwrap_or(0)
    }
    pub fn clear_gamepad_count(&mut self) {
        self.gamepad_count = ::std::option::Option::None;
    }

    pub fn has_gamepad_count(&self) -> bool {
        self.gamepad_count.is_some()
    }

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

    // optional int32 launch_option = 4;


    pub fn get_launch_option(&self) -> i32 {
        self.launch_option.unwrap_or(-1i32)
    }
    pub fn clear_launch_option(&mut self) {
        self.launch_option = ::std::option::Option::None;
    }

    pub fn has_launch_option(&self) -> bool {
        self.launch_option.is_some()
    }

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

    // optional bool lock_parental_lock = 5;


    pub fn get_lock_parental_lock(&self) -> bool {
        self.lock_parental_lock.unwrap_or(false)
    }
    pub fn clear_lock_parental_lock(&mut self) {
        self.lock_parental_lock = ::std::option::Option::None;
    }

    pub fn has_lock_parental_lock(&self) -> bool {
        self.lock_parental_lock.is_some()
    }

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

    // optional string unlock_parental_lock = 6;


    pub fn get_unlock_parental_lock(&self) -> &str {
        match self.unlock_parental_lock.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_unlock_parental_lock(&mut self) {
        self.unlock_parental_lock.clear();
    }

    pub fn has_unlock_parental_lock(&self) -> bool {
        self.unlock_parental_lock.is_some()
    }

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

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

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

    // optional int32 maximum_resolution_x = 7;


    pub fn get_maximum_resolution_x(&self) -> i32 {
        self.maximum_resolution_x.unwrap_or(0)
    }
    pub fn clear_maximum_resolution_x(&mut self) {
        self.maximum_resolution_x = ::std::option::Option::None;
    }

    pub fn has_maximum_resolution_x(&self) -> bool {
        self.maximum_resolution_x.is_some()
    }

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

    // optional int32 maximum_resolution_y = 8;


    pub fn get_maximum_resolution_y(&self) -> i32 {
        self.maximum_resolution_y.unwrap_or(0)
    }
    pub fn clear_maximum_resolution_y(&mut self) {
        self.maximum_resolution_y = ::std::option::Option::None;
    }

    pub fn has_maximum_resolution_y(&self) -> bool {
        self.maximum_resolution_y.is_some()
    }

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

    // repeated .CMsgRemoteClientStartStream.ReservedGamepad gamepads = 9;


    pub fn get_gamepads(&self) -> &[CMsgRemoteClientStartStream_ReservedGamepad] {
        &self.gamepads
    }
    pub fn clear_gamepads(&mut self) {
        self.gamepads.clear();
    }

    // Param is passed by value, moved
    pub fn set_gamepads(&mut self, v: ::protobuf::RepeatedField<CMsgRemoteClientStartStream_ReservedGamepad>) {
        self.gamepads = v;
    }

    // Mutable pointer to the field.
    pub fn mut_gamepads(&mut self) -> &mut ::protobuf::RepeatedField<CMsgRemoteClientStartStream_ReservedGamepad> {
        &mut self.gamepads
    }

    // Take field
    pub fn take_gamepads(&mut self) -> ::protobuf::RepeatedField<CMsgRemoteClientStartStream_ReservedGamepad> {
        ::std::mem::replace(&mut self.gamepads, ::protobuf::RepeatedField::new())
    }

    // optional int32 audio_channel_count = 10;


    pub fn get_audio_channel_count(&self) -> i32 {
        self.audio_channel_count.unwrap_or(2i32)
    }
    pub fn clear_audio_channel_count(&mut self) {
        self.audio_channel_count = ::std::option::Option::None;
    }

    pub fn has_audio_channel_count(&self) -> bool {
        self.audio_channel_count.is_some()
    }

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

    // repeated .EStreamTransport supported_transport = 11;


    pub fn get_supported_transport(&self) -> &[super::steammessages_remoteclient_discovery::EStreamTransport] {
        &self.supported_transport
    }
    pub fn clear_supported_transport(&mut self) {
        self.supported_transport.clear();
    }

    // Param is passed by value, moved
    pub fn set_supported_transport(&mut self, v: ::std::vec::Vec<super::steammessages_remoteclient_discovery::EStreamTransport>) {
        self.supported_transport = v;
    }

    // Mutable pointer to the field.
    pub fn mut_supported_transport(&mut self) -> &mut ::std::vec::Vec<super::steammessages_remoteclient_discovery::EStreamTransport> {
        &mut self.supported_transport
    }

    // Take field
    pub fn take_supported_transport(&mut self) -> ::std::vec::Vec<super::steammessages_remoteclient_discovery::EStreamTransport> {
        ::std::mem::replace(&mut self.supported_transport, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CMsgRemoteClientStartStream {
    fn is_initialized(&self) -> bool {
        for v in &self.gamepads {
            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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.app_id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.environment = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.gamepad_count = ::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_int32()?;
                    self.launch_option = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.lock_parental_lock = ::std::option::Option::Some(tmp);
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.unlock_parental_lock)?;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.maximum_resolution_x = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.maximum_resolution_y = ::std::option::Option::Some(tmp);
                },
                9 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.gamepads)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.audio_channel_count = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_repeated_enum_with_unknown_fields_into(wire_type, is, &mut self.supported_transport, 11, &mut self.unknown_fields)?
                },
                _ => {
                    ::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.app_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.environment {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.gamepad_count {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.launch_option {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.lock_parental_lock {
            my_size += 2;
        }
        if let Some(ref v) = self.unlock_parental_lock.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.maximum_resolution_x {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.maximum_resolution_y {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.gamepads {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.audio_channel_count {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.supported_transport {
            my_size += ::protobuf::rt::enum_size(11, *value);
        };
        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.app_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.environment {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.gamepad_count {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.launch_option {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.lock_parental_lock {
            os.write_bool(5, v)?;
        }
        if let Some(ref v) = self.unlock_parental_lock.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(v) = self.maximum_resolution_x {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.maximum_resolution_y {
            os.write_int32(8, v)?;
        }
        for v in &self.gamepads {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.audio_channel_count {
            os.write_int32(10, v)?;
        }
        for v in &self.supported_transport {
            os.write_enum(11, ::protobuf::ProtobufEnum::value(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() -> CMsgRemoteClientStartStream {
        CMsgRemoteClientStartStream::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::ProtobufTypeUint32>(
                "app_id",
                |m: &CMsgRemoteClientStartStream| { &m.app_id },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.app_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "environment",
                |m: &CMsgRemoteClientStartStream| { &m.environment },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.environment },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "gamepad_count",
                |m: &CMsgRemoteClientStartStream| { &m.gamepad_count },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.gamepad_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "launch_option",
                |m: &CMsgRemoteClientStartStream| { &m.launch_option },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.launch_option },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "lock_parental_lock",
                |m: &CMsgRemoteClientStartStream| { &m.lock_parental_lock },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.lock_parental_lock },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "unlock_parental_lock",
                |m: &CMsgRemoteClientStartStream| { &m.unlock_parental_lock },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.unlock_parental_lock },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "maximum_resolution_x",
                |m: &CMsgRemoteClientStartStream| { &m.maximum_resolution_x },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.maximum_resolution_x },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "maximum_resolution_y",
                |m: &CMsgRemoteClientStartStream| { &m.maximum_resolution_y },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.maximum_resolution_y },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CMsgRemoteClientStartStream_ReservedGamepad>>(
                "gamepads",
                |m: &CMsgRemoteClientStartStream| { &m.gamepads },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.gamepads },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "audio_channel_count",
                |m: &CMsgRemoteClientStartStream| { &m.audio_channel_count },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.audio_channel_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::steammessages_remoteclient_discovery::EStreamTransport>>(
                "supported_transport",
                |m: &CMsgRemoteClientStartStream| { &m.supported_transport },
                |m: &mut CMsgRemoteClientStartStream| { &mut m.supported_transport },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientStartStream>(
                "CMsgRemoteClientStartStream",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientStartStream {
    fn clear(&mut self) {
        self.app_id = ::std::option::Option::None;
        self.environment = ::std::option::Option::None;
        self.gamepad_count = ::std::option::Option::None;
        self.launch_option = ::std::option::Option::None;
        self.lock_parental_lock = ::std::option::Option::None;
        self.unlock_parental_lock.clear();
        self.maximum_resolution_x = ::std::option::Option::None;
        self.maximum_resolution_y = ::std::option::Option::None;
        self.gamepads.clear();
        self.audio_channel_count = ::std::option::Option::None;
        self.supported_transport.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 controller_type = 1;


    pub fn get_controller_type(&self) -> u32 {
        self.controller_type.unwrap_or(0)
    }
    pub fn clear_controller_type(&mut self) {
        self.controller_type = ::std::option::Option::None;
    }

    pub fn has_controller_type(&self) -> bool {
        self.controller_type.is_some()
    }

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

    // optional uint32 controller_subtype = 2;


    pub fn get_controller_subtype(&self) -> u32 {
        self.controller_subtype.unwrap_or(0)
    }
    pub fn clear_controller_subtype(&mut self) {
        self.controller_subtype = ::std::option::Option::None;
    }

    pub fn has_controller_subtype(&self) -> bool {
        self.controller_subtype.is_some()
    }

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

impl ::protobuf::Message for CMsgRemoteClientStartStream_ReservedGamepad {
    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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.controller_type = ::std::option::Option::Some(tmp);
                },
                2 => {
                    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.controller_subtype = ::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.controller_type {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.controller_subtype {
            my_size += ::protobuf::rt::value_size(2, 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.controller_type {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.controller_subtype {
            os.write_uint32(2, 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() -> CMsgRemoteClientStartStream_ReservedGamepad {
        CMsgRemoteClientStartStream_ReservedGamepad::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::ProtobufTypeUint32>(
                "controller_type",
                |m: &CMsgRemoteClientStartStream_ReservedGamepad| { &m.controller_type },
                |m: &mut CMsgRemoteClientStartStream_ReservedGamepad| { &mut m.controller_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "controller_subtype",
                |m: &CMsgRemoteClientStartStream_ReservedGamepad| { &m.controller_subtype },
                |m: &mut CMsgRemoteClientStartStream_ReservedGamepad| { &mut m.controller_subtype },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientStartStream_ReservedGamepad>(
                "CMsgRemoteClientStartStream.ReservedGamepad",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientStartStream_ReservedGamepad {
    fn clear(&mut self) {
        self.controller_type = ::std::option::Option::None;
        self.controller_subtype = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientStartStreamResponse {
    // message fields
    e_launch_result: ::std::option::Option<i32>,
    stream_port: ::std::option::Option<u32>,
    pub launch_options: ::std::vec::Vec<i32>,
    auth_token: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    transport: ::std::option::Option<super::steammessages_remoteclient_discovery::EStreamTransport>,
    relay_server: ::protobuf::SingularField<::std::string::String>,
    launch_task: ::protobuf::SingularField<::std::string::String>,
    launch_task_detail: ::protobuf::SingularField<::std::string::String>,
    launch_tasks_done: ::std::option::Option<i32>,
    launch_tasks_total: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 e_launch_result = 1;


    pub fn get_e_launch_result(&self) -> i32 {
        self.e_launch_result.unwrap_or(2i32)
    }
    pub fn clear_e_launch_result(&mut self) {
        self.e_launch_result = ::std::option::Option::None;
    }

    pub fn has_e_launch_result(&self) -> bool {
        self.e_launch_result.is_some()
    }

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

    // optional uint32 stream_port = 2;


    pub fn get_stream_port(&self) -> u32 {
        self.stream_port.unwrap_or(0)
    }
    pub fn clear_stream_port(&mut self) {
        self.stream_port = ::std::option::Option::None;
    }

    pub fn has_stream_port(&self) -> bool {
        self.stream_port.is_some()
    }

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

    // repeated int32 launch_options = 3;


    pub fn get_launch_options(&self) -> &[i32] {
        &self.launch_options
    }
    pub fn clear_launch_options(&mut self) {
        self.launch_options.clear();
    }

    // Param is passed by value, moved
    pub fn set_launch_options(&mut self, v: ::std::vec::Vec<i32>) {
        self.launch_options = v;
    }

    // Mutable pointer to the field.
    pub fn mut_launch_options(&mut self) -> &mut ::std::vec::Vec<i32> {
        &mut self.launch_options
    }

    // Take field
    pub fn take_launch_options(&mut self) -> ::std::vec::Vec<i32> {
        ::std::mem::replace(&mut self.launch_options, ::std::vec::Vec::new())
    }

    // optional bytes auth_token = 4;


    pub fn get_auth_token(&self) -> &[u8] {
        match self.auth_token.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_auth_token(&mut self) {
        self.auth_token.clear();
    }

    pub fn has_auth_token(&self) -> bool {
        self.auth_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_auth_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.auth_token = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_auth_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.auth_token.is_none() {
            self.auth_token.set_default();
        }
        self.auth_token.as_mut().unwrap()
    }

    // Take field
    pub fn take_auth_token(&mut self) -> ::std::vec::Vec<u8> {
        self.auth_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional .EStreamTransport transport = 5;


    pub fn get_transport(&self) -> super::steammessages_remoteclient_discovery::EStreamTransport {
        self.transport.unwrap_or(super::steammessages_remoteclient_discovery::EStreamTransport::k_EStreamTransportUDP)
    }
    pub fn clear_transport(&mut self) {
        self.transport = ::std::option::Option::None;
    }

    pub fn has_transport(&self) -> bool {
        self.transport.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transport(&mut self, v: super::steammessages_remoteclient_discovery::EStreamTransport) {
        self.transport = ::std::option::Option::Some(v);
    }

    // optional string relay_server = 6;


    pub fn get_relay_server(&self) -> &str {
        match self.relay_server.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_relay_server(&mut self) {
        self.relay_server.clear();
    }

    pub fn has_relay_server(&self) -> bool {
        self.relay_server.is_some()
    }

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

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

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

    // optional string launch_task = 7;


    pub fn get_launch_task(&self) -> &str {
        match self.launch_task.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_launch_task(&mut self) {
        self.launch_task.clear();
    }

    pub fn has_launch_task(&self) -> bool {
        self.launch_task.is_some()
    }

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

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

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

    // optional string launch_task_detail = 8;


    pub fn get_launch_task_detail(&self) -> &str {
        match self.launch_task_detail.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_launch_task_detail(&mut self) {
        self.launch_task_detail.clear();
    }

    pub fn has_launch_task_detail(&self) -> bool {
        self.launch_task_detail.is_some()
    }

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

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

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

    // optional int32 launch_tasks_done = 9;


    pub fn get_launch_tasks_done(&self) -> i32 {
        self.launch_tasks_done.unwrap_or(0)
    }
    pub fn clear_launch_tasks_done(&mut self) {
        self.launch_tasks_done = ::std::option::Option::None;
    }

    pub fn has_launch_tasks_done(&self) -> bool {
        self.launch_tasks_done.is_some()
    }

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

    // optional int32 launch_tasks_total = 10;


    pub fn get_launch_tasks_total(&self) -> i32 {
        self.launch_tasks_total.unwrap_or(0)
    }
    pub fn clear_launch_tasks_total(&mut self) {
        self.launch_tasks_total = ::std::option::Option::None;
    }

    pub fn has_launch_tasks_total(&self) -> bool {
        self.launch_tasks_total.is_some()
    }

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

impl ::protobuf::Message for CMsgRemoteClientStartStreamResponse {
    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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.e_launch_result = ::std::option::Option::Some(tmp);
                },
                2 => {
                    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.stream_port = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.launch_options)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.auth_token)?;
                },
                5 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.transport, 5, &mut self.unknown_fields)?
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.relay_server)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.launch_task)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.launch_task_detail)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.launch_tasks_done = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.launch_tasks_total = ::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.e_launch_result {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.stream_port {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.launch_options {
            my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(ref v) = self.auth_token.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(v) = self.transport {
            my_size += ::protobuf::rt::enum_size(5, v);
        }
        if let Some(ref v) = self.relay_server.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(ref v) = self.launch_task.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(ref v) = self.launch_task_detail.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.launch_tasks_done {
            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.launch_tasks_total {
            my_size += ::protobuf::rt::value_size(10, 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.e_launch_result {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.stream_port {
            os.write_uint32(2, v)?;
        }
        for v in &self.launch_options {
            os.write_int32(3, *v)?;
        };
        if let Some(ref v) = self.auth_token.as_ref() {
            os.write_bytes(4, &v)?;
        }
        if let Some(v) = self.transport {
            os.write_enum(5, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(ref v) = self.relay_server.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(ref v) = self.launch_task.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(ref v) = self.launch_task_detail.as_ref() {
            os.write_string(8, &v)?;
        }
        if let Some(v) = self.launch_tasks_done {
            os.write_int32(9, v)?;
        }
        if let Some(v) = self.launch_tasks_total {
            os.write_int32(10, 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() -> CMsgRemoteClientStartStreamResponse {
        CMsgRemoteClientStartStreamResponse::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::ProtobufTypeInt32>(
                "e_launch_result",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.e_launch_result },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.e_launch_result },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "stream_port",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.stream_port },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.stream_port },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "launch_options",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.launch_options },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.launch_options },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "auth_token",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.auth_token },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.auth_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::steammessages_remoteclient_discovery::EStreamTransport>>(
                "transport",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.transport },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.transport },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "relay_server",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.relay_server },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.relay_server },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "launch_task",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.launch_task },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.launch_task },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "launch_task_detail",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.launch_task_detail },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.launch_task_detail },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "launch_tasks_done",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.launch_tasks_done },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.launch_tasks_done },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "launch_tasks_total",
                |m: &CMsgRemoteClientStartStreamResponse| { &m.launch_tasks_total },
                |m: &mut CMsgRemoteClientStartStreamResponse| { &mut m.launch_tasks_total },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientStartStreamResponse>(
                "CMsgRemoteClientStartStreamResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientStartStreamResponse {
    fn clear(&mut self) {
        self.e_launch_result = ::std::option::Option::None;
        self.stream_port = ::std::option::Option::None;
        self.launch_options.clear();
        self.auth_token.clear();
        self.transport = ::std::option::Option::None;
        self.relay_server.clear();
        self.launch_task.clear();
        self.launch_task_detail.clear();
        self.launch_tasks_done = ::std::option::Option::None;
        self.launch_tasks_total = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientPing {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

impl ::protobuf::Message for CMsgRemoteClientPing {
    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 {
                _ => {
                    ::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;
        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<()> {
        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() -> CMsgRemoteClientPing {
        CMsgRemoteClientPing::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientPing>(
                "CMsgRemoteClientPing",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientPing {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientPingResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

impl ::protobuf::Message for CMsgRemoteClientPingResponse {
    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 {
                _ => {
                    ::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;
        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<()> {
        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() -> CMsgRemoteClientPingResponse {
        CMsgRemoteClientPingResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientPingResponse>(
                "CMsgRemoteClientPingResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientPingResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientAcceptEULA {
    // message fields
    pub app_id: ::std::vec::Vec<u32>,
    pub eula_id: ::protobuf::RepeatedField<::std::string::String>,
    pub eula_version: ::std::vec::Vec<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated uint32 app_id = 1;


    pub fn get_app_id(&self) -> &[u32] {
        &self.app_id
    }
    pub fn clear_app_id(&mut self) {
        self.app_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_id(&mut self, v: ::std::vec::Vec<u32>) {
        self.app_id = v;
    }

    // Mutable pointer to the field.
    pub fn mut_app_id(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.app_id
    }

    // Take field
    pub fn take_app_id(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.app_id, ::std::vec::Vec::new())
    }

    // repeated string eula_id = 2;


    pub fn get_eula_id(&self) -> &[::std::string::String] {
        &self.eula_id
    }
    pub fn clear_eula_id(&mut self) {
        self.eula_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_eula_id(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.eula_id = v;
    }

    // Mutable pointer to the field.
    pub fn mut_eula_id(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.eula_id
    }

    // Take field
    pub fn take_eula_id(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.eula_id, ::protobuf::RepeatedField::new())
    }

    // repeated uint32 eula_version = 3;


    pub fn get_eula_version(&self) -> &[u32] {
        &self.eula_version
    }
    pub fn clear_eula_version(&mut self) {
        self.eula_version.clear();
    }

    // Param is passed by value, moved
    pub fn set_eula_version(&mut self, v: ::std::vec::Vec<u32>) {
        self.eula_version = v;
    }

    // Mutable pointer to the field.
    pub fn mut_eula_version(&mut self) -> &mut ::std::vec::Vec<u32> {
        &mut self.eula_version
    }

    // Take field
    pub fn take_eula_version(&mut self) -> ::std::vec::Vec<u32> {
        ::std::mem::replace(&mut self.eula_version, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CMsgRemoteClientAcceptEULA {
    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 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.app_id)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.eula_id)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.eula_version)?;
                },
                _ => {
                    ::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;
        for value in &self.app_id {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in &self.eula_id {
            my_size += ::protobuf::rt::string_size(2, &value);
        };
        for value in &self.eula_version {
            my_size += ::protobuf::rt::value_size(3, *value, ::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<()> {
        for v in &self.app_id {
            os.write_uint32(1, *v)?;
        };
        for v in &self.eula_id {
            os.write_string(2, &v)?;
        };
        for v in &self.eula_version {
            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() -> CMsgRemoteClientAcceptEULA {
        CMsgRemoteClientAcceptEULA::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_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "app_id",
                |m: &CMsgRemoteClientAcceptEULA| { &m.app_id },
                |m: &mut CMsgRemoteClientAcceptEULA| { &mut m.app_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "eula_id",
                |m: &CMsgRemoteClientAcceptEULA| { &m.eula_id },
                |m: &mut CMsgRemoteClientAcceptEULA| { &mut m.eula_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "eula_version",
                |m: &CMsgRemoteClientAcceptEULA| { &m.eula_version },
                |m: &mut CMsgRemoteClientAcceptEULA| { &mut m.eula_version },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientAcceptEULA>(
                "CMsgRemoteClientAcceptEULA",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientAcceptEULA {
    fn clear(&mut self) {
        self.app_id.clear();
        self.eula_id.clear();
        self.eula_version.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 app_id = 1;


    pub fn get_app_id(&self) -> u32 {
        self.app_id.unwrap_or(0)
    }
    pub fn clear_app_id(&mut self) {
        self.app_id = ::std::option::Option::None;
    }

    pub fn has_app_id(&self) -> bool {
        self.app_id.is_some()
    }

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

    // optional uint32 controller_index = 3;


    pub fn get_controller_index(&self) -> u32 {
        self.controller_index.unwrap_or(0)
    }
    pub fn clear_controller_index(&mut self) {
        self.controller_index = ::std::option::Option::None;
    }

    pub fn has_controller_index(&self) -> bool {
        self.controller_index.is_some()
    }

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

impl ::protobuf::Message for CMsgRemoteClientGetControllerConfig {
    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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.app_id = ::std::option::Option::Some(tmp);
                },
                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.controller_index = ::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.app_id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.controller_index {
            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.app_id {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.controller_index {
            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() -> CMsgRemoteClientGetControllerConfig {
        CMsgRemoteClientGetControllerConfig::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::ProtobufTypeUint32>(
                "app_id",
                |m: &CMsgRemoteClientGetControllerConfig| { &m.app_id },
                |m: &mut CMsgRemoteClientGetControllerConfig| { &mut m.app_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "controller_index",
                |m: &CMsgRemoteClientGetControllerConfig| { &m.controller_index },
                |m: &mut CMsgRemoteClientGetControllerConfig| { &mut m.controller_index },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientGetControllerConfig>(
                "CMsgRemoteClientGetControllerConfig",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientGetControllerConfig {
    fn clear(&mut self) {
        self.app_id = ::std::option::Option::None;
        self.controller_index = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CMsgRemoteClientGetControllerConfigResponse {
    // message fields
    eresult: ::std::option::Option<i32>,
    config_vdf: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 eresult = 1;


    pub fn get_eresult(&self) -> i32 {
        self.eresult.unwrap_or(2i32)
    }
    pub fn clear_eresult(&mut self) {
        self.eresult = ::std::option::Option::None;
    }

    pub fn has_eresult(&self) -> bool {
        self.eresult.is_some()
    }

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

    // optional bytes config_vdf = 2;


    pub fn get_config_vdf(&self) -> &[u8] {
        match self.config_vdf.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_config_vdf(&mut self) {
        self.config_vdf.clear();
    }

    pub fn has_config_vdf(&self) -> bool {
        self.config_vdf.is_some()
    }

    // Param is passed by value, moved
    pub fn set_config_vdf(&mut self, v: ::std::vec::Vec<u8>) {
        self.config_vdf = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_config_vdf(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.config_vdf.is_none() {
            self.config_vdf.set_default();
        }
        self.config_vdf.as_mut().unwrap()
    }

    // Take field
    pub fn take_config_vdf(&mut self) -> ::std::vec::Vec<u8> {
        self.config_vdf.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for CMsgRemoteClientGetControllerConfigResponse {
    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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.eresult = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.config_vdf)?;
                },
                _ => {
                    ::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.eresult {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.config_vdf.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        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.eresult {
            os.write_int32(1, v)?;
        }
        if let Some(ref v) = self.config_vdf.as_ref() {
            os.write_bytes(2, &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() -> CMsgRemoteClientGetControllerConfigResponse {
        CMsgRemoteClientGetControllerConfigResponse::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::ProtobufTypeInt32>(
                "eresult",
                |m: &CMsgRemoteClientGetControllerConfigResponse| { &m.eresult },
                |m: &mut CMsgRemoteClientGetControllerConfigResponse| { &mut m.eresult },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "config_vdf",
                |m: &CMsgRemoteClientGetControllerConfigResponse| { &m.config_vdf },
                |m: &mut CMsgRemoteClientGetControllerConfigResponse| { &mut m.config_vdf },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientGetControllerConfigResponse>(
                "CMsgRemoteClientGetControllerConfigResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CMsgRemoteClientGetControllerConfigResponse {
    fn clear(&mut self) {
        self.eresult = ::std::option::Option::None;
        self.config_vdf.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // required bool enabled = 1;


    pub fn get_enabled(&self) -> bool {
        self.enabled.unwrap_or(false)
    }
    pub fn clear_enabled(&mut self) {
        self.enabled = ::std::option::Option::None;
    }

    pub fn has_enabled(&self) -> bool {
        self.enabled.is_some()
    }

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

impl ::protobuf::Message for CMsgRemoteClientStreamingEnabled {
    fn is_initialized(&self) -> bool {
        if self.enabled.is_none() {
            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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.enabled = ::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.enabled {
            my_size += 2;
        }
        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.enabled {
            os.write_bool(1, 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() -> CMsgRemoteClientStreamingEnabled {
        CMsgRemoteClientStreamingEnabled::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::ProtobufTypeBool>(
                "enabled",
                |m: &CMsgRemoteClientStreamingEnabled| { &m.enabled },
                |m: &mut CMsgRemoteClientStreamingEnabled| { &mut m.enabled },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CMsgRemoteClientStreamingEnabled>(
                "CMsgRemoteClientStreamingEnabled",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x20steammessages_remoteclient.proto\x1a\x18steammessages_base.proto\
    \x1a*steammessages_remoteclient_discovery.proto\"\x90\x01\n\x16CMsgRemot\
    eClientStatus\x12\x1b\n\tclient_id\x18\x01\x20\x01(\x04R\x08clientId\x12\
    \x1f\n\x0binstance_id\x18\x02\x20\x01(\x04R\ninstanceId\x128\n\x06status\
    \x18\x03\x20\x01(\x0b2\x20.CMsgRemoteClientBroadcastStatusR\x06status\"\
    \xda\x06\n\x19CMsgRemoteClientAppStatus\x12K\n\x0estatus_updates\x18\x01\
    \x20\x03(\x0b2$.CMsgRemoteClientAppStatus.AppStatusR\rstatusUpdates\x1a\
    \xf1\x02\n\rAppUpdateInfo\x12*\n\x11time_update_start\x18\x01\x20\x01(\
    \x07R\x0ftimeUpdateStart\x12*\n\x11bytes_to_download\x18\x02\x20\x01(\
    \x04R\x0fbytesToDownload\x12)\n\x10bytes_downloaded\x18\x03\x20\x01(\x04\
    R\x0fbytesDownloaded\x12(\n\x10bytes_to_process\x18\x04\x20\x01(\x04R\
    \x0ebytesToProcess\x12'\n\x0fbytes_processed\x18\x05\x20\x01(\x04R\x0eby\
    tesProcessed\x12B\n\x1bestimated_seconds_remaining\x18\x06\x20\x01(\x05:\
    \x02-1R\x19estimatedSecondsRemaining\x12#\n\rupdate_result\x18\x07\x20\
    \x01(\x05R\x0cupdateResult\x12!\n\x0cupdate_state\x18\x08\x20\x01(\rR\
    \x0bupdateState\x1ap\n\x0cShortcutInfo\x12\x12\n\x04name\x18\x01\x20\x01\
    (\tR\x04name\x12\x12\n\x04icon\x18\x02\x20\x01(\tR\x04icon\x12\x1e\n\nca\
    tegories\x18\x03\x20\x03(\tR\ncategories\x12\x18\n\x07exepath\x18\x04\
    \x20\x01(\tR\x07exepath\x1a\x89\x02\n\tAppStatus\x12\x15\n\x06app_id\x18\
    \x01\x20\x01(\rR\x05appId\x12\x1b\n\tapp_state\x18\x02\x20\x01(\rR\x08ap\
    pState\x12I\n\x0bupdate_info\x18\x03\x20\x01(\x0b2(.CMsgRemoteClientAppS\
    tatus.AppUpdateInfoR\nupdateInfo\x12L\n\rshortcut_info\x18\x04\x20\x01(\
    \x0b2'.CMsgRemoteClientAppStatus.ShortcutInfoR\x0cshortcutInfo\x12/\n\
    \x10launch_available\x18\x05\x20\x01(\x08:\x04trueR\x0flaunchAvailable\"\
    \x9b\x05\n\x1bCMsgRemoteClientStartStream\x12\x15\n\x06app_id\x18\x01\
    \x20\x01(\rR\x05appId\x12\x20\n\x0benvironment\x18\x02\x20\x01(\x05R\x0b\
    environment\x12#\n\rgamepad_count\x18\x03\x20\x01(\x05R\x0cgamepadCount\
    \x12'\n\rlaunch_option\x18\x04\x20\x01(\x05:\x02-1R\x0claunchOption\x123\
    \n\x12lock_parental_lock\x18\x05\x20\x01(\x08:\x05falseR\x10lockParental\
    Lock\x120\n\x14unlock_parental_lock\x18\x06\x20\x01(\tR\x12unlockParenta\
    lLock\x120\n\x14maximum_resolution_x\x18\x07\x20\x01(\x05R\x12maximumRes\
    olutionX\x120\n\x14maximum_resolution_y\x18\x08\x20\x01(\x05R\x12maximum\
    ResolutionY\x12H\n\x08gamepads\x18\t\x20\x03(\x0b2,.CMsgRemoteClientStar\
    tStream.ReservedGamepadR\x08gamepads\x121\n\x13audio_channel_count\x18\n\
    \x20\x01(\x05:\x012R\x11audioChannelCount\x12B\n\x13supported_transport\
    \x18\x0b\x20\x03(\x0e2\x11.EStreamTransportR\x12supportedTransport\x1ai\
    \n\x0fReservedGamepad\x12'\n\x0fcontroller_type\x18\x01\x20\x01(\rR\x0ec\
    ontrollerType\x12-\n\x12controller_subtype\x18\x02\x20\x01(\rR\x11contro\
    llerSubtype\"\xcb\x03\n#CMsgRemoteClientStartStreamResponse\x12)\n\x0fe_\
    launch_result\x18\x01\x20\x01(\x05:\x012R\reLaunchResult\x12\x1f\n\x0bst\
    ream_port\x18\x02\x20\x01(\rR\nstreamPort\x12%\n\x0elaunch_options\x18\
    \x03\x20\x03(\x05R\rlaunchOptions\x12\x1d\n\nauth_token\x18\x04\x20\x01(\
    \x0cR\tauthToken\x12F\n\ttransport\x18\x05\x20\x01(\x0e2\x11.EStreamTran\
    sport:\x15k_EStreamTransportUDPR\ttransport\x12!\n\x0crelay_server\x18\
    \x06\x20\x01(\tR\x0brelayServer\x12\x1f\n\x0blaunch_task\x18\x07\x20\x01\
    (\tR\nlaunchTask\x12,\n\x12launch_task_detail\x18\x08\x20\x01(\tR\x10lau\
    nchTaskDetail\x12*\n\x11launch_tasks_done\x18\t\x20\x01(\x05R\x0flaunchT\
    asksDone\x12,\n\x12launch_tasks_total\x18\n\x20\x01(\x05R\x10launchTasks\
    Total\"\x16\n\x14CMsgRemoteClientPing\"\x1e\n\x1cCMsgRemoteClientPingRes\
    ponse\"o\n\x1aCMsgRemoteClientAcceptEULA\x12\x15\n\x06app_id\x18\x01\x20\
    \x03(\rR\x05appId\x12\x17\n\x07eula_id\x18\x02\x20\x03(\tR\x06eulaId\x12\
    !\n\x0ceula_version\x18\x03\x20\x03(\rR\x0beulaVersion\"g\n#CMsgRemoteCl\
    ientGetControllerConfig\x12\x15\n\x06app_id\x18\x01\x20\x01(\rR\x05appId\
    \x12)\n\x10controller_index\x18\x03\x20\x01(\rR\x0fcontrollerIndex\"i\n+\
    CMsgRemoteClientGetControllerConfigResponse\x12\x1b\n\x07eresult\x18\x01\
    \x20\x01(\x05:\x012R\x07eresult\x12\x1d\n\nconfig_vdf\x18\x02\x20\x01(\
    \x0cR\tconfigVdf\"<\n\x20CMsgRemoteClientStreamingEnabled\x12\x18\n\x07e\
    nabled\x18\x01\x20\x02(\x08R\x07enabledB\x05H\x01\x80\x01\0J\xd2\"\n\x06\
    \x12\x04\0\0b\x01\n\t\n\x02\x03\0\x12\x03\0\0\"\n\t\n\x02\x03\x01\x12\
    \x03\x01\04\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\x04\0\x12\x04\x06\0\n\x01\n\n\n\x03\x04\0\x01\x12\x03\x06\
    \x08\x1e\n\x0b\n\x04\x04\0\x02\0\x12\x03\x07\x08&\n\x0c\n\x05\x04\0\x02\
    \0\x04\x12\x03\x07\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x07\x11\
    \x17\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x07\x18!\n\x0c\n\x05\x04\0\x02\
    \0\x03\x12\x03\x07$%\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x08\x08(\n\x0c\n\
    \x05\x04\0\x02\x01\x04\x12\x03\x08\x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\
    \x12\x03\x08\x11\x17\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x08\x18#\n\
    \x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x08&'\n\x0b\n\x04\x04\0\x02\x02\x12\
    \x03\t\x08=\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03\t\x08\x10\n\x0c\n\x05\
    \x04\0\x02\x02\x06\x12\x03\t\x111\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\
    \t28\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\t;<\n\n\n\x02\x04\x01\x12\x04\
    \x0c\0(\x01\n\n\n\x03\x04\x01\x01\x12\x03\x0c\x08!\n\x0c\n\x04\x04\x01\
    \x03\0\x12\x04\r\x08\x16\t\n\x0c\n\x05\x04\x01\x03\0\x01\x12\x03\r\x10\
    \x1d\n\r\n\x06\x04\x01\x03\0\x02\0\x12\x03\x0e\x107\n\x0e\n\x07\x04\x01\
    \x03\0\x02\0\x04\x12\x03\x0e\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\0\x05\
    \x12\x03\x0e\x19\x20\n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\x12\x03\x0e!2\n\
    \x0e\n\x07\x04\x01\x03\0\x02\0\x03\x12\x03\x0e56\n\r\n\x06\x04\x01\x03\0\
    \x02\x01\x12\x03\x0f\x106\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x04\x12\x03\
    \x0f\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x05\x12\x03\x0f\x19\x1f\n\
    \x0e\n\x07\x04\x01\x03\0\x02\x01\x01\x12\x03\x0f\x201\n\x0e\n\x07\x04\
    \x01\x03\0\x02\x01\x03\x12\x03\x0f45\n\r\n\x06\x04\x01\x03\0\x02\x02\x12\
    \x03\x10\x105\n\x0e\n\x07\x04\x01\x03\0\x02\x02\x04\x12\x03\x10\x10\x18\
    \n\x0e\n\x07\x04\x01\x03\0\x02\x02\x05\x12\x03\x10\x19\x1f\n\x0e\n\x07\
    \x04\x01\x03\0\x02\x02\x01\x12\x03\x10\x200\n\x0e\n\x07\x04\x01\x03\0\
    \x02\x02\x03\x12\x03\x1034\n\r\n\x06\x04\x01\x03\0\x02\x03\x12\x03\x11\
    \x105\n\x0e\n\x07\x04\x01\x03\0\x02\x03\x04\x12\x03\x11\x10\x18\n\x0e\n\
    \x07\x04\x01\x03\0\x02\x03\x05\x12\x03\x11\x19\x1f\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x03\x01\x12\x03\x11\x200\n\x0e\n\x07\x04\x01\x03\0\x02\x03\
    \x03\x12\x03\x1134\n\r\n\x06\x04\x01\x03\0\x02\x04\x12\x03\x12\x104\n\
    \x0e\n\x07\x04\x01\x03\0\x02\x04\x04\x12\x03\x12\x10\x18\n\x0e\n\x07\x04\
    \x01\x03\0\x02\x04\x05\x12\x03\x12\x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\
    \x04\x01\x12\x03\x12\x20/\n\x0e\n\x07\x04\x01\x03\0\x02\x04\x03\x12\x03\
    \x1223\n\r\n\x06\x04\x01\x03\0\x02\x05\x12\x03\x13\x10N\n\x0e\n\x07\x04\
    \x01\x03\0\x02\x05\x04\x12\x03\x13\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\
    \x05\x05\x12\x03\x13\x19\x1e\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x01\x12\
    \x03\x13\x1f:\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x03\x12\x03\x13=>\n\x0e\
    \n\x07\x04\x01\x03\0\x02\x05\x08\x12\x03\x13?M\n\x0e\n\x07\x04\x01\x03\0\
    \x02\x05\x07\x12\x03\x13JL\n\r\n\x06\x04\x01\x03\0\x02\x06\x12\x03\x14\
    \x101\n\x0e\n\x07\x04\x01\x03\0\x02\x06\x04\x12\x03\x14\x10\x18\n\x0e\n\
    \x07\x04\x01\x03\0\x02\x06\x05\x12\x03\x14\x19\x1e\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x06\x01\x12\x03\x14\x1f,\n\x0e\n\x07\x04\x01\x03\0\x02\x06\
    \x03\x12\x03\x14/0\n\r\n\x06\x04\x01\x03\0\x02\x07\x12\x03\x15\x101\n\
    \x0e\n\x07\x04\x01\x03\0\x02\x07\x04\x12\x03\x15\x10\x18\n\x0e\n\x07\x04\
    \x01\x03\0\x02\x07\x05\x12\x03\x15\x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\
    \x07\x01\x12\x03\x15\x20,\n\x0e\n\x07\x04\x01\x03\0\x02\x07\x03\x12\x03\
    \x15/0\n\x0c\n\x04\x04\x01\x03\x01\x12\x04\x18\x08\x1d\t\n\x0c\n\x05\x04\
    \x01\x03\x01\x01\x12\x03\x18\x10\x1c\n\r\n\x06\x04\x01\x03\x01\x02\0\x12\
    \x03\x19\x10)\n\x0e\n\x07\x04\x01\x03\x01\x02\0\x04\x12\x03\x19\x10\x18\
    \n\x0e\n\x07\x04\x01\x03\x01\x02\0\x05\x12\x03\x19\x19\x1f\n\x0e\n\x07\
    \x04\x01\x03\x01\x02\0\x01\x12\x03\x19\x20$\n\x0e\n\x07\x04\x01\x03\x01\
    \x02\0\x03\x12\x03\x19'(\n\r\n\x06\x04\x01\x03\x01\x02\x01\x12\x03\x1a\
    \x10)\n\x0e\n\x07\x04\x01\x03\x01\x02\x01\x04\x12\x03\x1a\x10\x18\n\x0e\
    \n\x07\x04\x01\x03\x01\x02\x01\x05\x12\x03\x1a\x19\x1f\n\x0e\n\x07\x04\
    \x01\x03\x01\x02\x01\x01\x12\x03\x1a\x20$\n\x0e\n\x07\x04\x01\x03\x01\
    \x02\x01\x03\x12\x03\x1a'(\n\r\n\x06\x04\x01\x03\x01\x02\x02\x12\x03\x1b\
    \x10/\n\x0e\n\x07\x04\x01\x03\x01\x02\x02\x04\x12\x03\x1b\x10\x18\n\x0e\
    \n\x07\x04\x01\x03\x01\x02\x02\x05\x12\x03\x1b\x19\x1f\n\x0e\n\x07\x04\
    \x01\x03\x01\x02\x02\x01\x12\x03\x1b\x20*\n\x0e\n\x07\x04\x01\x03\x01\
    \x02\x02\x03\x12\x03\x1b-.\n\r\n\x06\x04\x01\x03\x01\x02\x03\x12\x03\x1c\
    \x10,\n\x0e\n\x07\x04\x01\x03\x01\x02\x03\x04\x12\x03\x1c\x10\x18\n\x0e\
    \n\x07\x04\x01\x03\x01\x02\x03\x05\x12\x03\x1c\x19\x1f\n\x0e\n\x07\x04\
    \x01\x03\x01\x02\x03\x01\x12\x03\x1c\x20'\n\x0e\n\x07\x04\x01\x03\x01\
    \x02\x03\x03\x12\x03\x1c*+\n\x0c\n\x04\x04\x01\x03\x02\x12\x04\x1f\x08%\
    \t\n\x0c\n\x05\x04\x01\x03\x02\x01\x12\x03\x1f\x10\x19\n\r\n\x06\x04\x01\
    \x03\x02\x02\0\x12\x03\x20\x10+\n\x0e\n\x07\x04\x01\x03\x02\x02\0\x04\
    \x12\x03\x20\x10\x18\n\x0e\n\x07\x04\x01\x03\x02\x02\0\x05\x12\x03\x20\
    \x19\x1f\n\x0e\n\x07\x04\x01\x03\x02\x02\0\x01\x12\x03\x20\x20&\n\x0e\n\
    \x07\x04\x01\x03\x02\x02\0\x03\x12\x03\x20)*\n\r\n\x06\x04\x01\x03\x02\
    \x02\x01\x12\x03!\x10.\n\x0e\n\x07\x04\x01\x03\x02\x02\x01\x04\x12\x03!\
    \x10\x18\n\x0e\n\x07\x04\x01\x03\x02\x02\x01\x05\x12\x03!\x19\x1f\n\x0e\
    \n\x07\x04\x01\x03\x02\x02\x01\x01\x12\x03!\x20)\n\x0e\n\x07\x04\x01\x03\
    \x02\x02\x01\x03\x12\x03!,-\n\r\n\x06\x04\x01\x03\x02\x02\x02\x12\x03\"\
    \x10R\n\x0e\n\x07\x04\x01\x03\x02\x02\x02\x04\x12\x03\"\x10\x18\n\x0e\n\
    \x07\x04\x01\x03\x02\x02\x02\x06\x12\x03\"\x19A\n\x0e\n\x07\x04\x01\x03\
    \x02\x02\x02\x01\x12\x03\"BM\n\x0e\n\x07\x04\x01\x03\x02\x02\x02\x03\x12\
    \x03\"PQ\n\r\n\x06\x04\x01\x03\x02\x02\x03\x12\x03#\x10S\n\x0e\n\x07\x04\
    \x01\x03\x02\x02\x03\x04\x12\x03#\x10\x18\n\x0e\n\x07\x04\x01\x03\x02\
    \x02\x03\x06\x12\x03#\x19@\n\x0e\n\x07\x04\x01\x03\x02\x02\x03\x01\x12\
    \x03#AN\n\x0e\n\x07\x04\x01\x03\x02\x02\x03\x03\x12\x03#QR\n\r\n\x06\x04\
    \x01\x03\x02\x02\x04\x12\x03$\x10D\n\x0e\n\x07\x04\x01\x03\x02\x02\x04\
    \x04\x12\x03$\x10\x18\n\x0e\n\x07\x04\x01\x03\x02\x02\x04\x05\x12\x03$\
    \x19\x1d\n\x0e\n\x07\x04\x01\x03\x02\x02\x04\x01\x12\x03$\x1e.\n\x0e\n\
    \x07\x04\x01\x03\x02\x02\x04\x03\x12\x03$12\n\x0e\n\x07\x04\x01\x03\x02\
    \x02\x04\x08\x12\x03$3C\n\x0e\n\x07\x04\x01\x03\x02\x02\x04\x07\x12\x03$\
    >B\n\x0b\n\x04\x04\x01\x02\0\x12\x03'\x08I\n\x0c\n\x05\x04\x01\x02\0\x04\
    \x12\x03'\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03'\x115\n\x0c\n\
    \x05\x04\x01\x02\0\x01\x12\x03'6D\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03'\
    GH\n\n\n\x02\x04\x02\x12\x04*\0;\x01\n\n\n\x03\x04\x02\x01\x12\x03*\x08#\
    \n\x0c\n\x04\x04\x02\x03\0\x12\x04+\x08.\t\n\x0c\n\x05\x04\x02\x03\0\x01\
    \x12\x03+\x10\x1f\n\r\n\x06\x04\x02\x03\0\x02\0\x12\x03,\x104\n\x0e\n\
    \x07\x04\x02\x03\0\x02\0\x04\x12\x03,\x10\x18\n\x0e\n\x07\x04\x02\x03\0\
    \x02\0\x05\x12\x03,\x19\x1f\n\x0e\n\x07\x04\x02\x03\0\x02\0\x01\x12\x03,\
    \x20/\n\x0e\n\x07\x04\x02\x03\0\x02\0\x03\x12\x03,23\n\r\n\x06\x04\x02\
    \x03\0\x02\x01\x12\x03-\x107\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x04\x12\
    \x03-\x10\x18\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x05\x12\x03-\x19\x1f\n\
    \x0e\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x03-\x202\n\x0e\n\x07\x04\x02\
    \x03\0\x02\x01\x03\x12\x03-56\n\x0b\n\x04\x04\x02\x02\0\x12\x030\x08#\n\
    \x0c\n\x05\x04\x02\x02\0\x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x02\x02\0\
    \x05\x12\x030\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x030\x18\x1e\n\
    \x0c\n\x05\x04\x02\x02\0\x03\x12\x030!\"\n\x0b\n\x04\x04\x02\x02\x01\x12\
    \x031\x08'\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x031\x08\x10\n\x0c\n\x05\
    \x04\x02\x02\x01\x05\x12\x031\x11\x16\n\x0c\n\x05\x04\x02\x02\x01\x01\
    \x12\x031\x17\"\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x031%&\n\x0b\n\x04\
    \x04\x02\x02\x02\x12\x032\x08)\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x032\
    \x08\x10\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x032\x11\x16\n\x0c\n\x05\
    \x04\x02\x02\x02\x01\x12\x032\x17$\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\
    \x032'(\n\x0b\n\x04\x04\x02\x02\x03\x12\x033\x088\n\x0c\n\x05\x04\x02\
    \x02\x03\x04\x12\x033\x08\x10\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x033\
    \x11\x16\n\x0c\n\x05\x04\x02\x02\x03\x01\x12\x033\x17$\n\x0c\n\x05\x04\
    \x02\x02\x03\x03\x12\x033'(\n\x0c\n\x05\x04\x02\x02\x03\x08\x12\x033)7\n\
    \x0c\n\x05\x04\x02\x02\x03\x07\x12\x03346\n\x0b\n\x04\x04\x02\x02\x04\
    \x12\x034\x08?\n\x0c\n\x05\x04\x02\x02\x04\x04\x12\x034\x08\x10\n\x0c\n\
    \x05\x04\x02\x02\x04\x05\x12\x034\x11\x15\n\x0c\n\x05\x04\x02\x02\x04\
    \x01\x12\x034\x16(\n\x0c\n\x05\x04\x02\x02\x04\x03\x12\x034+,\n\x0c\n\
    \x05\x04\x02\x02\x04\x08\x12\x034->\n\x0c\n\x05\x04\x02\x02\x04\x07\x12\
    \x0348=\n\x0b\n\x04\x04\x02\x02\x05\x12\x035\x081\n\x0c\n\x05\x04\x02\
    \x02\x05\x04\x12\x035\x08\x10\n\x0c\n\x05\x04\x02\x02\x05\x05\x12\x035\
    \x11\x17\n\x0c\n\x05\x04\x02\x02\x05\x01\x12\x035\x18,\n\x0c\n\x05\x04\
    \x02\x02\x05\x03\x12\x035/0\n\x0b\n\x04\x04\x02\x02\x06\x12\x036\x080\n\
    \x0c\n\x05\x04\x02\x02\x06\x04\x12\x036\x08\x10\n\x0c\n\x05\x04\x02\x02\
    \x06\x05\x12\x036\x11\x16\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\x036\x17+\
    \n\x0c\n\x05\x04\x02\x02\x06\x03\x12\x036./\n\x0b\n\x04\x04\x02\x02\x07\
    \x12\x037\x080\n\x0c\n\x05\x04\x02\x02\x07\x04\x12\x037\x08\x10\n\x0c\n\
    \x05\x04\x02\x02\x07\x05\x12\x037\x11\x16\n\x0c\n\x05\x04\x02\x02\x07\
    \x01\x12\x037\x17+\n\x0c\n\x05\x04\x02\x02\x07\x03\x12\x037./\n\x0b\n\
    \x04\x04\x02\x02\x08\x12\x038\x08K\n\x0c\n\x05\x04\x02\x02\x08\x04\x12\
    \x038\x08\x10\n\x0c\n\x05\x04\x02\x02\x08\x06\x12\x038\x11=\n\x0c\n\x05\
    \x04\x02\x02\x08\x01\x12\x038>F\n\x0c\n\x05\x04\x02\x02\x08\x03\x12\x038\
    IJ\n\x0b\n\x04\x04\x02\x02\t\x12\x039\x08>\n\x0c\n\x05\x04\x02\x02\t\x04\
    \x12\x039\x08\x10\n\x0c\n\x05\x04\x02\x02\t\x05\x12\x039\x11\x16\n\x0c\n\
    \x05\x04\x02\x02\t\x01\x12\x039\x17*\n\x0c\n\x05\x04\x02\x02\t\x03\x12\
    \x039-/\n\x0c\n\x05\x04\x02\x02\t\x08\x12\x0390=\n\x0c\n\x05\x04\x02\x02\
    \t\x07\x12\x039;<\n\x0b\n\x04\x04\x02\x02\n\x12\x03:\x08<\n\x0c\n\x05\
    \x04\x02\x02\n\x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\x02\x02\n\x06\x12\
    \x03:\x11\"\n\x0c\n\x05\x04\x02\x02\n\x01\x12\x03:#6\n\x0c\n\x05\x04\x02\
    \x02\n\x03\x12\x03:9;\n\n\n\x02\x04\x03\x12\x04=\0H\x01\n\n\n\x03\x04\
    \x03\x01\x12\x03=\x08+\n\x0b\n\x04\x04\x03\x02\0\x12\x03>\x089\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\x16\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03>\x17&\n\x0c\n\
    \x05\x04\x03\x02\0\x03\x12\x03>)*\n\x0c\n\x05\x04\x03\x02\0\x08\x12\x03>\
    +8\n\x0c\n\x05\x04\x03\x02\0\x07\x12\x03>67\n\x0b\n\x04\x04\x03\x02\x01\
    \x12\x03?\x08(\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\x17\n\x0c\n\x05\x04\x03\x02\x01\
    \x01\x12\x03?\x18#\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03?&'\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\x16\n\x0c\n\
    \x05\x04\x03\x02\x02\x01\x12\x03@\x17%\n\x0c\n\x05\x04\x03\x02\x02\x03\
    \x12\x03@()\n\x0b\n\x04\x04\x03\x02\x03\x12\x03A\x08&\n\x0c\n\x05\x04\
    \x03\x02\x03\x04\x12\x03A\x08\x10\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\
    \x03A\x11\x16\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03A\x17!\n\x0c\n\x05\
    \x04\x03\x02\x03\x03\x12\x03A$%\n\x0b\n\x04\x04\x03\x02\x04\x12\x03B\x08\
    S\n\x0c\n\x05\x04\x03\x02\x04\x04\x12\x03B\x08\x10\n\x0c\n\x05\x04\x03\
    \x02\x04\x06\x12\x03B\x11\"\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03B#,\n\
    \x0c\n\x05\x04\x03\x02\x04\x03\x12\x03B/0\n\x0c\n\x05\x04\x03\x02\x04\
    \x08\x12\x03B1R\n\x0c\n\x05\x04\x03\x02\x04\x07\x12\x03B<Q\n\x0b\n\x04\
    \x04\x03\x02\x05\x12\x03C\x08)\n\x0c\n\x05\x04\x03\x02\x05\x04\x12\x03C\
    \x08\x10\n\x0c\n\x05\x04\x03\x02\x05\x05\x12\x03C\x11\x17\n\x0c\n\x05\
    \x04\x03\x02\x05\x01\x12\x03C\x18$\n\x0c\n\x05\x04\x03\x02\x05\x03\x12\
    \x03C'(\n\x0b\n\x04\x04\x03\x02\x06\x12\x03D\x08(\n\x0c\n\x05\x04\x03\
    \x02\x06\x04\x12\x03D\x08\x10\n\x0c\n\x05\x04\x03\x02\x06\x05\x12\x03D\
    \x11\x17\n\x0c\n\x05\x04\x03\x02\x06\x01\x12\x03D\x18#\n\x0c\n\x05\x04\
    \x03\x02\x06\x03\x12\x03D&'\n\x0b\n\x04\x04\x03\x02\x07\x12\x03E\x08/\n\
    \x0c\n\x05\x04\x03\x02\x07\x04\x12\x03E\x08\x10\n\x0c\n\x05\x04\x03\x02\
    \x07\x05\x12\x03E\x11\x17\n\x0c\n\x05\x04\x03\x02\x07\x01\x12\x03E\x18*\
    \n\x0c\n\x05\x04\x03\x02\x07\x03\x12\x03E-.\n\x0b\n\x04\x04\x03\x02\x08\
    \x12\x03F\x08-\n\x0c\n\x05\x04\x03\x02\x08\x04\x12\x03F\x08\x10\n\x0c\n\
    \x05\x04\x03\x02\x08\x05\x12\x03F\x11\x16\n\x0c\n\x05\x04\x03\x02\x08\
    \x01\x12\x03F\x17(\n\x0c\n\x05\x04\x03\x02\x08\x03\x12\x03F+,\n\x0b\n\
    \x04\x04\x03\x02\t\x12\x03G\x08/\n\x0c\n\x05\x04\x03\x02\t\x04\x12\x03G\
    \x08\x10\n\x0c\n\x05\x04\x03\x02\t\x05\x12\x03G\x11\x16\n\x0c\n\x05\x04\
    \x03\x02\t\x01\x12\x03G\x17)\n\x0c\n\x05\x04\x03\x02\t\x03\x12\x03G,.\n\
    \n\n\x02\x04\x04\x12\x04J\0K\x01\n\n\n\x03\x04\x04\x01\x12\x03J\x08\x1c\
    \n\n\n\x02\x04\x05\x12\x04M\0N\x01\n\n\n\x03\x04\x05\x01\x12\x03M\x08$\n\
    \n\n\x02\x04\x06\x12\x04P\0T\x01\n\n\n\x03\x04\x06\x01\x12\x03P\x08\"\n\
    \x0b\n\x04\x04\x06\x02\0\x12\x03Q\x08#\n\x0c\n\x05\x04\x06\x02\0\x04\x12\
    \x03Q\x08\x10\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03Q\x11\x17\n\x0c\n\x05\
    \x04\x06\x02\0\x01\x12\x03Q\x18\x1e\n\x0c\n\x05\x04\x06\x02\0\x03\x12\
    \x03Q!\"\n\x0b\n\x04\x04\x06\x02\x01\x12\x03R\x08$\n\x0c\n\x05\x04\x06\
    \x02\x01\x04\x12\x03R\x08\x10\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03R\
    \x11\x17\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03R\x18\x1f\n\x0c\n\x05\
    \x04\x06\x02\x01\x03\x12\x03R\"#\n\x0b\n\x04\x04\x06\x02\x02\x12\x03S\
    \x08)\n\x0c\n\x05\x04\x06\x02\x02\x04\x12\x03S\x08\x10\n\x0c\n\x05\x04\
    \x06\x02\x02\x05\x12\x03S\x11\x17\n\x0c\n\x05\x04\x06\x02\x02\x01\x12\
    \x03S\x18$\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\x03S'(\n\n\n\x02\x04\x07\
    \x12\x04V\0Y\x01\n\n\n\x03\x04\x07\x01\x12\x03V\x08+\n\x0b\n\x04\x04\x07\
    \x02\0\x12\x03W\x08#\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03W\x08\x10\n\
    \x0c\n\x05\x04\x07\x02\0\x05\x12\x03W\x11\x17\n\x0c\n\x05\x04\x07\x02\0\
    \x01\x12\x03W\x18\x1e\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03W!\"\n\x0b\n\
    \x04\x04\x07\x02\x01\x12\x03X\x08-\n\x0c\n\x05\x04\x07\x02\x01\x04\x12\
    \x03X\x08\x10\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\x03X\x11\x17\n\x0c\n\
    \x05\x04\x07\x02\x01\x01\x12\x03X\x18(\n\x0c\n\x05\x04\x07\x02\x01\x03\
    \x12\x03X+,\n\n\n\x02\x04\x08\x12\x04[\0^\x01\n\n\n\x03\x04\x08\x01\x12\
    \x03[\x083\n\x0b\n\x04\x04\x08\x02\0\x12\x03\\\x081\n\x0c\n\x05\x04\x08\
    \x02\0\x04\x12\x03\\\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03\\\x11\
    \x16\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03\\\x17\x1e\n\x0c\n\x05\x04\x08\
    \x02\0\x03\x12\x03\\!\"\n\x0c\n\x05\x04\x08\x02\0\x08\x12\x03\\#0\n\x0c\
    \n\x05\x04\x08\x02\0\x07\x12\x03\\./\n\x0b\n\x04\x04\x08\x02\x01\x12\x03\
    ]\x08&\n\x0c\n\x05\x04\x08\x02\x01\x04\x12\x03]\x08\x10\n\x0c\n\x05\x04\
    \x08\x02\x01\x05\x12\x03]\x11\x16\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\
    \x03]\x17!\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x03]$%\n\n\n\x02\x04\t\
    \x12\x04`\0b\x01\n\n\n\x03\x04\t\x01\x12\x03`\x08(\n\x0b\n\x04\x04\t\x02\
    \0\x12\x03a\x08\"\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03a\x08\x10\n\x0c\n\
    \x05\x04\t\x02\0\x05\x12\x03a\x11\x15\n\x0c\n\x05\x04\t\x02\0\x01\x12\
    \x03a\x16\x1d\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03a\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()
    })
}