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_deviceauth.steamclient.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 CDeviceAuth_GetOwnAuthorizedDevices_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    include_canceled: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional bool include_canceled = 2;


    pub fn get_include_canceled(&self) -> bool {
        self.include_canceled.unwrap_or(false)
    }
    pub fn clear_include_canceled(&mut self) {
        self.include_canceled = ::std::option::Option::None;
    }

    pub fn has_include_canceled(&self) -> bool {
        self.include_canceled.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetOwnAuthorizedDevices_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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_bool()?;
                    self.include_canceled = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.include_canceled {
            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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.include_canceled {
            os.write_bool(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() -> CDeviceAuth_GetOwnAuthorizedDevices_Request {
        CDeviceAuth_GetOwnAuthorizedDevices_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Request| { &m.steamid },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_canceled",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Request| { &m.include_canceled },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Request| { &mut m.include_canceled },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetOwnAuthorizedDevices_Request>(
                "CDeviceAuth_GetOwnAuthorizedDevices_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated .CDeviceAuth_GetOwnAuthorizedDevices_Response.Device devices = 1;


    pub fn get_devices(&self) -> &[CDeviceAuth_GetOwnAuthorizedDevices_Response_Device] {
        &self.devices
    }
    pub fn clear_devices(&mut self) {
        self.devices.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_devices(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetOwnAuthorizedDevices_Response_Device> {
        &mut self.devices
    }

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

impl ::protobuf::Message for CDeviceAuth_GetOwnAuthorizedDevices_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.devices {
            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.devices)?;
                },
                _ => {
                    ::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.devices {
            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.devices {
            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() -> CDeviceAuth_GetOwnAuthorizedDevices_Response {
        CDeviceAuth_GetOwnAuthorizedDevices_Response::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<CDeviceAuth_GetOwnAuthorizedDevices_Response_Device>>(
                "devices",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response| { &m.devices },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response| { &mut m.devices },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetOwnAuthorizedDevices_Response>(
                "CDeviceAuth_GetOwnAuthorizedDevices_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_GetOwnAuthorizedDevices_Response_Device {
    // message fields
    auth_device_token: ::std::option::Option<u64>,
    device_name: ::protobuf::SingularField<::std::string::String>,
    is_pending: ::std::option::Option<bool>,
    is_canceled: ::std::option::Option<bool>,
    last_time_used: ::std::option::Option<u32>,
    last_borrower_id: ::std::option::Option<u64>,
    last_app_played: ::std::option::Option<u32>,
    is_limited: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 auth_device_token = 1;


    pub fn get_auth_device_token(&self) -> u64 {
        self.auth_device_token.unwrap_or(0)
    }
    pub fn clear_auth_device_token(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
    }

    pub fn has_auth_device_token(&self) -> bool {
        self.auth_device_token.is_some()
    }

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

    // optional string device_name = 2;


    pub fn get_device_name(&self) -> &str {
        match self.device_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_device_name(&mut self) {
        self.device_name.clear();
    }

    pub fn has_device_name(&self) -> bool {
        self.device_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device_name(&mut self, v: ::std::string::String) {
        self.device_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_device_name(&mut self) -> &mut ::std::string::String {
        if self.device_name.is_none() {
            self.device_name.set_default();
        }
        self.device_name.as_mut().unwrap()
    }

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

    // optional bool is_pending = 3;


    pub fn get_is_pending(&self) -> bool {
        self.is_pending.unwrap_or(false)
    }
    pub fn clear_is_pending(&mut self) {
        self.is_pending = ::std::option::Option::None;
    }

    pub fn has_is_pending(&self) -> bool {
        self.is_pending.is_some()
    }

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

    // optional bool is_canceled = 4;


    pub fn get_is_canceled(&self) -> bool {
        self.is_canceled.unwrap_or(false)
    }
    pub fn clear_is_canceled(&mut self) {
        self.is_canceled = ::std::option::Option::None;
    }

    pub fn has_is_canceled(&self) -> bool {
        self.is_canceled.is_some()
    }

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

    // optional uint32 last_time_used = 5;


    pub fn get_last_time_used(&self) -> u32 {
        self.last_time_used.unwrap_or(0)
    }
    pub fn clear_last_time_used(&mut self) {
        self.last_time_used = ::std::option::Option::None;
    }

    pub fn has_last_time_used(&self) -> bool {
        self.last_time_used.is_some()
    }

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

    // optional fixed64 last_borrower_id = 6;


    pub fn get_last_borrower_id(&self) -> u64 {
        self.last_borrower_id.unwrap_or(0)
    }
    pub fn clear_last_borrower_id(&mut self) {
        self.last_borrower_id = ::std::option::Option::None;
    }

    pub fn has_last_borrower_id(&self) -> bool {
        self.last_borrower_id.is_some()
    }

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

    // optional uint32 last_app_played = 7;


    pub fn get_last_app_played(&self) -> u32 {
        self.last_app_played.unwrap_or(0)
    }
    pub fn clear_last_app_played(&mut self) {
        self.last_app_played = ::std::option::Option::None;
    }

    pub fn has_last_app_played(&self) -> bool {
        self.last_app_played.is_some()
    }

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

    // optional bool is_limited = 8;


    pub fn get_is_limited(&self) -> bool {
        self.is_limited.unwrap_or(false)
    }
    pub fn clear_is_limited(&mut self) {
        self.is_limited = ::std::option::Option::None;
    }

    pub fn has_is_limited(&self) -> bool {
        self.is_limited.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetOwnAuthorizedDevices_Response_Device {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.auth_device_token = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_name)?;
                },
                3 => {
                    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.is_pending = ::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_bool()?;
                    self.is_canceled = ::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_uint32()?;
                    self.last_time_used = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.last_borrower_id = ::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_uint32()?;
                    self.last_app_played = ::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_bool()?;
                    self.is_limited = ::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.auth_device_token {
            my_size += 9;
        }
        if let Some(ref v) = self.device_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.is_pending {
            my_size += 2;
        }
        if let Some(v) = self.is_canceled {
            my_size += 2;
        }
        if let Some(v) = self.last_time_used {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.last_borrower_id {
            my_size += 9;
        }
        if let Some(v) = self.last_app_played {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.is_limited {
            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.auth_device_token {
            os.write_fixed64(1, v)?;
        }
        if let Some(ref v) = self.device_name.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.is_pending {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.is_canceled {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.last_time_used {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.last_borrower_id {
            os.write_fixed64(6, v)?;
        }
        if let Some(v) = self.last_app_played {
            os.write_uint32(7, v)?;
        }
        if let Some(v) = self.is_limited {
            os.write_bool(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() -> CDeviceAuth_GetOwnAuthorizedDevices_Response_Device {
        CDeviceAuth_GetOwnAuthorizedDevices_Response_Device::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::ProtobufTypeFixed64>(
                "auth_device_token",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.auth_device_token },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.auth_device_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "device_name",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.device_name },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.device_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_pending",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.is_pending },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.is_pending },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_canceled",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.is_canceled },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.is_canceled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "last_time_used",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.last_time_used },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.last_time_used },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "last_borrower_id",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.last_borrower_id },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.last_borrower_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "last_app_played",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.last_app_played },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.last_app_played },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_limited",
                |m: &CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &m.is_limited },
                |m: &mut CDeviceAuth_GetOwnAuthorizedDevices_Response_Device| { &mut m.is_limited },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetOwnAuthorizedDevices_Response_Device>(
                "CDeviceAuth_GetOwnAuthorizedDevices_Response.Device",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetOwnAuthorizedDevices_Response_Device {
    fn clear(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
        self.device_name.clear();
        self.is_pending = ::std::option::Option::None;
        self.is_canceled = ::std::option::Option::None;
        self.last_time_used = ::std::option::Option::None;
        self.last_borrower_id = ::std::option::Option::None;
        self.last_app_played = ::std::option::Option::None;
        self.is_limited = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_AcceptAuthorizationRequest_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    auth_device_token: ::std::option::Option<u64>,
    auth_code: ::std::option::Option<u64>,
    from_steamid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional fixed64 auth_device_token = 2;


    pub fn get_auth_device_token(&self) -> u64 {
        self.auth_device_token.unwrap_or(0)
    }
    pub fn clear_auth_device_token(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
    }

    pub fn has_auth_device_token(&self) -> bool {
        self.auth_device_token.is_some()
    }

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

    // optional fixed64 auth_code = 3;


    pub fn get_auth_code(&self) -> u64 {
        self.auth_code.unwrap_or(0)
    }
    pub fn clear_auth_code(&mut self) {
        self.auth_code = ::std::option::Option::None;
    }

    pub fn has_auth_code(&self) -> bool {
        self.auth_code.is_some()
    }

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

    // optional fixed64 from_steamid = 4;


    pub fn get_from_steamid(&self) -> u64 {
        self.from_steamid.unwrap_or(0)
    }
    pub fn clear_from_steamid(&mut self) {
        self.from_steamid = ::std::option::Option::None;
    }

    pub fn has_from_steamid(&self) -> bool {
        self.from_steamid.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_AcceptAuthorizationRequest_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.auth_device_token = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.auth_code = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.from_steamid = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.auth_device_token {
            my_size += 9;
        }
        if let Some(v) = self.auth_code {
            my_size += 9;
        }
        if let Some(v) = self.from_steamid {
            my_size += 9;
        }
        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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.auth_device_token {
            os.write_fixed64(2, v)?;
        }
        if let Some(v) = self.auth_code {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.from_steamid {
            os.write_fixed64(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() -> CDeviceAuth_AcceptAuthorizationRequest_Request {
        CDeviceAuth_AcceptAuthorizationRequest_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_AcceptAuthorizationRequest_Request| { &m.steamid },
                |m: &mut CDeviceAuth_AcceptAuthorizationRequest_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "auth_device_token",
                |m: &CDeviceAuth_AcceptAuthorizationRequest_Request| { &m.auth_device_token },
                |m: &mut CDeviceAuth_AcceptAuthorizationRequest_Request| { &mut m.auth_device_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "auth_code",
                |m: &CDeviceAuth_AcceptAuthorizationRequest_Request| { &m.auth_code },
                |m: &mut CDeviceAuth_AcceptAuthorizationRequest_Request| { &mut m.auth_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "from_steamid",
                |m: &CDeviceAuth_AcceptAuthorizationRequest_Request| { &m.from_steamid },
                |m: &mut CDeviceAuth_AcceptAuthorizationRequest_Request| { &mut m.from_steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_AcceptAuthorizationRequest_Request>(
                "CDeviceAuth_AcceptAuthorizationRequest_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_AcceptAuthorizationRequest_Request {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.auth_device_token = ::std::option::Option::None;
        self.auth_code = ::std::option::Option::None;
        self.from_steamid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

impl ::protobuf::Message for CDeviceAuth_AcceptAuthorizationRequest_Response {
    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() -> CDeviceAuth_AcceptAuthorizationRequest_Response {
        CDeviceAuth_AcceptAuthorizationRequest_Response::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::<CDeviceAuth_AcceptAuthorizationRequest_Response>(
                "CDeviceAuth_AcceptAuthorizationRequest_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional fixed64 auth_device_token = 2;


    pub fn get_auth_device_token(&self) -> u64 {
        self.auth_device_token.unwrap_or(0)
    }
    pub fn clear_auth_device_token(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
    }

    pub fn has_auth_device_token(&self) -> bool {
        self.auth_device_token.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_AuthorizeRemoteDevice_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.auth_device_token = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.auth_device_token {
            my_size += 9;
        }
        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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.auth_device_token {
            os.write_fixed64(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() -> CDeviceAuth_AuthorizeRemoteDevice_Request {
        CDeviceAuth_AuthorizeRemoteDevice_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_AuthorizeRemoteDevice_Request| { &m.steamid },
                |m: &mut CDeviceAuth_AuthorizeRemoteDevice_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "auth_device_token",
                |m: &CDeviceAuth_AuthorizeRemoteDevice_Request| { &m.auth_device_token },
                |m: &mut CDeviceAuth_AuthorizeRemoteDevice_Request| { &mut m.auth_device_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_AuthorizeRemoteDevice_Request>(
                "CDeviceAuth_AuthorizeRemoteDevice_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for CDeviceAuth_AuthorizeRemoteDevice_Response {
    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() -> CDeviceAuth_AuthorizeRemoteDevice_Response {
        CDeviceAuth_AuthorizeRemoteDevice_Response::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::<CDeviceAuth_AuthorizeRemoteDevice_Response>(
                "CDeviceAuth_AuthorizeRemoteDevice_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional fixed64 auth_device_token = 2;


    pub fn get_auth_device_token(&self) -> u64 {
        self.auth_device_token.unwrap_or(0)
    }
    pub fn clear_auth_device_token(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
    }

    pub fn has_auth_device_token(&self) -> bool {
        self.auth_device_token.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_DeauthorizeRemoteDevice_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.auth_device_token = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.auth_device_token {
            my_size += 9;
        }
        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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.auth_device_token {
            os.write_fixed64(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() -> CDeviceAuth_DeauthorizeRemoteDevice_Request {
        CDeviceAuth_DeauthorizeRemoteDevice_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_DeauthorizeRemoteDevice_Request| { &m.steamid },
                |m: &mut CDeviceAuth_DeauthorizeRemoteDevice_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "auth_device_token",
                |m: &CDeviceAuth_DeauthorizeRemoteDevice_Request| { &m.auth_device_token },
                |m: &mut CDeviceAuth_DeauthorizeRemoteDevice_Request| { &mut m.auth_device_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_DeauthorizeRemoteDevice_Request>(
                "CDeviceAuth_DeauthorizeRemoteDevice_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for CDeviceAuth_DeauthorizeRemoteDevice_Response {
    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() -> CDeviceAuth_DeauthorizeRemoteDevice_Response {
        CDeviceAuth_DeauthorizeRemoteDevice_Response::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::<CDeviceAuth_DeauthorizeRemoteDevice_Response>(
                "CDeviceAuth_DeauthorizeRemoteDevice_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetUsedAuthorizedDevices_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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.steamid {
            my_size += 9;
        }
        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.steamid {
            os.write_fixed64(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() -> CDeviceAuth_GetUsedAuthorizedDevices_Request {
        CDeviceAuth_GetUsedAuthorizedDevices_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Request| { &m.steamid },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetUsedAuthorizedDevices_Request>(
                "CDeviceAuth_GetUsedAuthorizedDevices_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated .CDeviceAuth_GetUsedAuthorizedDevices_Response.Device devices = 1;


    pub fn get_devices(&self) -> &[CDeviceAuth_GetUsedAuthorizedDevices_Response_Device] {
        &self.devices
    }
    pub fn clear_devices(&mut self) {
        self.devices.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_devices(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetUsedAuthorizedDevices_Response_Device> {
        &mut self.devices
    }

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

impl ::protobuf::Message for CDeviceAuth_GetUsedAuthorizedDevices_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.devices {
            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.devices)?;
                },
                _ => {
                    ::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.devices {
            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.devices {
            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() -> CDeviceAuth_GetUsedAuthorizedDevices_Response {
        CDeviceAuth_GetUsedAuthorizedDevices_Response::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<CDeviceAuth_GetUsedAuthorizedDevices_Response_Device>>(
                "devices",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Response| { &m.devices },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Response| { &mut m.devices },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetUsedAuthorizedDevices_Response>(
                "CDeviceAuth_GetUsedAuthorizedDevices_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_GetUsedAuthorizedDevices_Response_Device {
    // message fields
    auth_device_token: ::std::option::Option<u64>,
    device_name: ::protobuf::SingularField<::std::string::String>,
    owner_steamid: ::std::option::Option<u64>,
    last_time_used: ::std::option::Option<u32>,
    last_app_played: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 auth_device_token = 1;


    pub fn get_auth_device_token(&self) -> u64 {
        self.auth_device_token.unwrap_or(0)
    }
    pub fn clear_auth_device_token(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
    }

    pub fn has_auth_device_token(&self) -> bool {
        self.auth_device_token.is_some()
    }

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

    // optional string device_name = 2;


    pub fn get_device_name(&self) -> &str {
        match self.device_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_device_name(&mut self) {
        self.device_name.clear();
    }

    pub fn has_device_name(&self) -> bool {
        self.device_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_device_name(&mut self, v: ::std::string::String) {
        self.device_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_device_name(&mut self) -> &mut ::std::string::String {
        if self.device_name.is_none() {
            self.device_name.set_default();
        }
        self.device_name.as_mut().unwrap()
    }

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

    // optional fixed64 owner_steamid = 3;


    pub fn get_owner_steamid(&self) -> u64 {
        self.owner_steamid.unwrap_or(0)
    }
    pub fn clear_owner_steamid(&mut self) {
        self.owner_steamid = ::std::option::Option::None;
    }

    pub fn has_owner_steamid(&self) -> bool {
        self.owner_steamid.is_some()
    }

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

    // optional uint32 last_time_used = 4;


    pub fn get_last_time_used(&self) -> u32 {
        self.last_time_used.unwrap_or(0)
    }
    pub fn clear_last_time_used(&mut self) {
        self.last_time_used = ::std::option::Option::None;
    }

    pub fn has_last_time_used(&self) -> bool {
        self.last_time_used.is_some()
    }

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

    // optional uint32 last_app_played = 5;


    pub fn get_last_app_played(&self) -> u32 {
        self.last_app_played.unwrap_or(0)
    }
    pub fn clear_last_app_played(&mut self) {
        self.last_app_played = ::std::option::Option::None;
    }

    pub fn has_last_app_played(&self) -> bool {
        self.last_app_played.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetUsedAuthorizedDevices_Response_Device {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.auth_device_token = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_name)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.owner_steamid = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.last_time_used = ::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_uint32()?;
                    self.last_app_played = ::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.auth_device_token {
            my_size += 9;
        }
        if let Some(ref v) = self.device_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.owner_steamid {
            my_size += 9;
        }
        if let Some(v) = self.last_time_used {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.last_app_played {
            my_size += ::protobuf::rt::value_size(5, 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.auth_device_token {
            os.write_fixed64(1, v)?;
        }
        if let Some(ref v) = self.device_name.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.owner_steamid {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.last_time_used {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.last_app_played {
            os.write_uint32(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() -> CDeviceAuth_GetUsedAuthorizedDevices_Response_Device {
        CDeviceAuth_GetUsedAuthorizedDevices_Response_Device::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::ProtobufTypeFixed64>(
                "auth_device_token",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &m.auth_device_token },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &mut m.auth_device_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "device_name",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &m.device_name },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &mut m.device_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "owner_steamid",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &m.owner_steamid },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &mut m.owner_steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "last_time_used",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &m.last_time_used },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &mut m.last_time_used },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "last_app_played",
                |m: &CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &m.last_app_played },
                |m: &mut CDeviceAuth_GetUsedAuthorizedDevices_Response_Device| { &mut m.last_app_played },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetUsedAuthorizedDevices_Response_Device>(
                "CDeviceAuth_GetUsedAuthorizedDevices_Response.Device",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetUsedAuthorizedDevices_Response_Device {
    fn clear(&mut self) {
        self.auth_device_token = ::std::option::Option::None;
        self.device_name.clear();
        self.owner_steamid = ::std::option::Option::None;
        self.last_time_used = ::std::option::Option::None;
        self.last_app_played = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional bool include_canceled = 2;


    pub fn get_include_canceled(&self) -> bool {
        self.include_canceled.unwrap_or(false)
    }
    pub fn clear_include_canceled(&mut self) {
        self.include_canceled = ::std::option::Option::None;
    }

    pub fn has_include_canceled(&self) -> bool {
        self.include_canceled.is_some()
    }

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

    // optional bool include_pending = 3;


    pub fn get_include_pending(&self) -> bool {
        self.include_pending.unwrap_or(false)
    }
    pub fn clear_include_pending(&mut self) {
        self.include_pending = ::std::option::Option::None;
    }

    pub fn has_include_pending(&self) -> bool {
        self.include_pending.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetAuthorizedBorrowers_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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_bool()?;
                    self.include_canceled = ::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_bool()?;
                    self.include_pending = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.include_canceled {
            my_size += 2;
        }
        if let Some(v) = self.include_pending {
            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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.include_canceled {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.include_pending {
            os.write_bool(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() -> CDeviceAuth_GetAuthorizedBorrowers_Request {
        CDeviceAuth_GetAuthorizedBorrowers_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Request| { &m.steamid },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_canceled",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Request| { &m.include_canceled },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Request| { &mut m.include_canceled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_pending",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Request| { &m.include_pending },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Request| { &mut m.include_pending },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetAuthorizedBorrowers_Request>(
                "CDeviceAuth_GetAuthorizedBorrowers_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetAuthorizedBorrowers_Request {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.include_canceled = ::std::option::Option::None;
        self.include_pending = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // repeated .CDeviceAuth_GetAuthorizedBorrowers_Response.Borrower borrowers = 1;


    pub fn get_borrowers(&self) -> &[CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower] {
        &self.borrowers
    }
    pub fn clear_borrowers(&mut self) {
        self.borrowers.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_borrowers(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower> {
        &mut self.borrowers
    }

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

impl ::protobuf::Message for CDeviceAuth_GetAuthorizedBorrowers_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.borrowers {
            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.borrowers)?;
                },
                _ => {
                    ::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.borrowers {
            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.borrowers {
            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() -> CDeviceAuth_GetAuthorizedBorrowers_Response {
        CDeviceAuth_GetAuthorizedBorrowers_Response::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<CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower>>(
                "borrowers",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Response| { &m.borrowers },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Response| { &mut m.borrowers },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetAuthorizedBorrowers_Response>(
                "CDeviceAuth_GetAuthorizedBorrowers_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower {
    // message fields
    steamid: ::std::option::Option<u64>,
    is_pending: ::std::option::Option<bool>,
    is_canceled: ::std::option::Option<bool>,
    time_created: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional bool is_pending = 2;


    pub fn get_is_pending(&self) -> bool {
        self.is_pending.unwrap_or(false)
    }
    pub fn clear_is_pending(&mut self) {
        self.is_pending = ::std::option::Option::None;
    }

    pub fn has_is_pending(&self) -> bool {
        self.is_pending.is_some()
    }

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

    // optional bool is_canceled = 3;


    pub fn get_is_canceled(&self) -> bool {
        self.is_canceled.unwrap_or(false)
    }
    pub fn clear_is_canceled(&mut self) {
        self.is_canceled = ::std::option::Option::None;
    }

    pub fn has_is_canceled(&self) -> bool {
        self.is_canceled.is_some()
    }

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

    // optional uint32 time_created = 4;


    pub fn get_time_created(&self) -> u32 {
        self.time_created.unwrap_or(0)
    }
    pub fn clear_time_created(&mut self) {
        self.time_created = ::std::option::Option::None;
    }

    pub fn has_time_created(&self) -> bool {
        self.time_created.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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_bool()?;
                    self.is_pending = ::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_bool()?;
                    self.is_canceled = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.time_created = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.is_pending {
            my_size += 2;
        }
        if let Some(v) = self.is_canceled {
            my_size += 2;
        }
        if let Some(v) = self.time_created {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

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

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

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

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

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

    fn new() -> CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower {
        CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &m.steamid },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_pending",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &m.is_pending },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &mut m.is_pending },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_canceled",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &m.is_canceled },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &mut m.is_canceled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time_created",
                |m: &CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &m.time_created },
                |m: &mut CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower| { &mut m.time_created },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower>(
                "CDeviceAuth_GetAuthorizedBorrowers_Response.Borrower",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.is_pending = ::std::option::Option::None;
        self.is_canceled = ::std::option::Option::None;
        self.time_created = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_AddAuthorizedBorrowers_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    pub steamid_borrower: ::std::vec::Vec<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // repeated fixed64 steamid_borrower = 2;


    pub fn get_steamid_borrower(&self) -> &[u64] {
        &self.steamid_borrower
    }
    pub fn clear_steamid_borrower(&mut self) {
        self.steamid_borrower.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_steamid_borrower(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.steamid_borrower
    }

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

impl ::protobuf::Message for CDeviceAuth_AddAuthorizedBorrowers_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_repeated_fixed64_into(wire_type, is, &mut self.steamid_borrower)?;
                },
                _ => {
                    ::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.steamid {
            my_size += 9;
        }
        my_size += 9 * self.steamid_borrower.len() as u32;
        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.steamid {
            os.write_fixed64(1, v)?;
        }
        for v in &self.steamid_borrower {
            os.write_fixed64(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() -> CDeviceAuth_AddAuthorizedBorrowers_Request {
        CDeviceAuth_AddAuthorizedBorrowers_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_AddAuthorizedBorrowers_Request| { &m.steamid },
                |m: &mut CDeviceAuth_AddAuthorizedBorrowers_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid_borrower",
                |m: &CDeviceAuth_AddAuthorizedBorrowers_Request| { &m.steamid_borrower },
                |m: &mut CDeviceAuth_AddAuthorizedBorrowers_Request| { &mut m.steamid_borrower },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_AddAuthorizedBorrowers_Request>(
                "CDeviceAuth_AddAuthorizedBorrowers_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional int32 seconds_to_wait = 1;


    pub fn get_seconds_to_wait(&self) -> i32 {
        self.seconds_to_wait.unwrap_or(0)
    }
    pub fn clear_seconds_to_wait(&mut self) {
        self.seconds_to_wait = ::std::option::Option::None;
    }

    pub fn has_seconds_to_wait(&self) -> bool {
        self.seconds_to_wait.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_AddAuthorizedBorrowers_Response {
    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.seconds_to_wait = ::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.seconds_to_wait {
            my_size += ::protobuf::rt::value_size(1, 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.seconds_to_wait {
            os.write_int32(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() -> CDeviceAuth_AddAuthorizedBorrowers_Response {
        CDeviceAuth_AddAuthorizedBorrowers_Response::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>(
                "seconds_to_wait",
                |m: &CDeviceAuth_AddAuthorizedBorrowers_Response| { &m.seconds_to_wait },
                |m: &mut CDeviceAuth_AddAuthorizedBorrowers_Response| { &mut m.seconds_to_wait },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_AddAuthorizedBorrowers_Response>(
                "CDeviceAuth_AddAuthorizedBorrowers_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_RemoveAuthorizedBorrowers_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    pub steamid_borrower: ::std::vec::Vec<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // repeated fixed64 steamid_borrower = 2;


    pub fn get_steamid_borrower(&self) -> &[u64] {
        &self.steamid_borrower
    }
    pub fn clear_steamid_borrower(&mut self) {
        self.steamid_borrower.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_steamid_borrower(&mut self) -> &mut ::std::vec::Vec<u64> {
        &mut self.steamid_borrower
    }

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

impl ::protobuf::Message for CDeviceAuth_RemoveAuthorizedBorrowers_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_repeated_fixed64_into(wire_type, is, &mut self.steamid_borrower)?;
                },
                _ => {
                    ::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.steamid {
            my_size += 9;
        }
        my_size += 9 * self.steamid_borrower.len() as u32;
        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.steamid {
            os.write_fixed64(1, v)?;
        }
        for v in &self.steamid_borrower {
            os.write_fixed64(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() -> CDeviceAuth_RemoveAuthorizedBorrowers_Request {
        CDeviceAuth_RemoveAuthorizedBorrowers_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_RemoveAuthorizedBorrowers_Request| { &m.steamid },
                |m: &mut CDeviceAuth_RemoveAuthorizedBorrowers_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid_borrower",
                |m: &CDeviceAuth_RemoveAuthorizedBorrowers_Request| { &m.steamid_borrower },
                |m: &mut CDeviceAuth_RemoveAuthorizedBorrowers_Request| { &mut m.steamid_borrower },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_RemoveAuthorizedBorrowers_Request>(
                "CDeviceAuth_RemoveAuthorizedBorrowers_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

impl ::protobuf::Message for CDeviceAuth_RemoveAuthorizedBorrowers_Response {
    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() -> CDeviceAuth_RemoveAuthorizedBorrowers_Response {
        CDeviceAuth_RemoveAuthorizedBorrowers_Response::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::<CDeviceAuth_RemoveAuthorizedBorrowers_Response>(
                "CDeviceAuth_RemoveAuthorizedBorrowers_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional bool include_canceled = 2;


    pub fn get_include_canceled(&self) -> bool {
        self.include_canceled.unwrap_or(false)
    }
    pub fn clear_include_canceled(&mut self) {
        self.include_canceled = ::std::option::Option::None;
    }

    pub fn has_include_canceled(&self) -> bool {
        self.include_canceled.is_some()
    }

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

    // optional bool include_pending = 3;


    pub fn get_include_pending(&self) -> bool {
        self.include_pending.unwrap_or(false)
    }
    pub fn clear_include_pending(&mut self) {
        self.include_pending = ::std::option::Option::None;
    }

    pub fn has_include_pending(&self) -> bool {
        self.include_pending.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetAuthorizedAsBorrower_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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_bool()?;
                    self.include_canceled = ::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_bool()?;
                    self.include_pending = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.include_canceled {
            my_size += 2;
        }
        if let Some(v) = self.include_pending {
            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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.include_canceled {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.include_pending {
            os.write_bool(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() -> CDeviceAuth_GetAuthorizedAsBorrower_Request {
        CDeviceAuth_GetAuthorizedAsBorrower_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Request| { &m.steamid },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_canceled",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Request| { &m.include_canceled },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Request| { &mut m.include_canceled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_pending",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Request| { &m.include_pending },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Request| { &mut m.include_pending },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetAuthorizedAsBorrower_Request>(
                "CDeviceAuth_GetAuthorizedAsBorrower_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetAuthorizedAsBorrower_Request {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.include_canceled = ::std::option::Option::None;
        self.include_pending = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // repeated .CDeviceAuth_GetAuthorizedAsBorrower_Response.Lender lenders = 1;


    pub fn get_lenders(&self) -> &[CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender] {
        &self.lenders
    }
    pub fn clear_lenders(&mut self) {
        self.lenders.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_lenders(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender> {
        &mut self.lenders
    }

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

impl ::protobuf::Message for CDeviceAuth_GetAuthorizedAsBorrower_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.lenders {
            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.lenders)?;
                },
                _ => {
                    ::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.lenders {
            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.lenders {
            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() -> CDeviceAuth_GetAuthorizedAsBorrower_Response {
        CDeviceAuth_GetAuthorizedAsBorrower_Response::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<CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender>>(
                "lenders",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Response| { &m.lenders },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Response| { &mut m.lenders },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetAuthorizedAsBorrower_Response>(
                "CDeviceAuth_GetAuthorizedAsBorrower_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender {
    // message fields
    steamid: ::std::option::Option<u64>,
    time_created: ::std::option::Option<u32>,
    is_pending: ::std::option::Option<bool>,
    is_canceled: ::std::option::Option<bool>,
    is_used: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // optional uint32 time_created = 2;


    pub fn get_time_created(&self) -> u32 {
        self.time_created.unwrap_or(0)
    }
    pub fn clear_time_created(&mut self) {
        self.time_created = ::std::option::Option::None;
    }

    pub fn has_time_created(&self) -> bool {
        self.time_created.is_some()
    }

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

    // optional bool is_pending = 3;


    pub fn get_is_pending(&self) -> bool {
        self.is_pending.unwrap_or(false)
    }
    pub fn clear_is_pending(&mut self) {
        self.is_pending = ::std::option::Option::None;
    }

    pub fn has_is_pending(&self) -> bool {
        self.is_pending.is_some()
    }

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

    // optional bool is_canceled = 4;


    pub fn get_is_canceled(&self) -> bool {
        self.is_canceled.unwrap_or(false)
    }
    pub fn clear_is_canceled(&mut self) {
        self.is_canceled = ::std::option::Option::None;
    }

    pub fn has_is_canceled(&self) -> bool {
        self.is_canceled.is_some()
    }

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

    // optional bool is_used = 5;


    pub fn get_is_used(&self) -> bool {
        self.is_used.unwrap_or(false)
    }
    pub fn clear_is_used(&mut self) {
        self.is_used = ::std::option::Option::None;
    }

    pub fn has_is_used(&self) -> bool {
        self.is_used.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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.time_created = ::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_bool()?;
                    self.is_pending = ::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_bool()?;
                    self.is_canceled = ::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.is_used = ::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.steamid {
            my_size += 9;
        }
        if let Some(v) = self.time_created {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.is_pending {
            my_size += 2;
        }
        if let Some(v) = self.is_canceled {
            my_size += 2;
        }
        if let Some(v) = self.is_used {
            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.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.time_created {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.is_pending {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.is_canceled {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.is_used {
            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() -> CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender {
        CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &m.steamid },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time_created",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &m.time_created },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &mut m.time_created },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_pending",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &m.is_pending },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &mut m.is_pending },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_canceled",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &m.is_canceled },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &mut m.is_canceled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_used",
                |m: &CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &m.is_used },
                |m: &mut CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender| { &mut m.is_used },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender>(
                "CDeviceAuth_GetAuthorizedAsBorrower_Response.Lender",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetAuthorizedAsBorrower_Response_Lender {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.time_created = ::std::option::Option::None;
        self.is_pending = ::std::option::Option::None;
        self.is_canceled = ::std::option::Option::None;
        self.is_used = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetExcludedGamesInLibrary_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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.steamid {
            my_size += 9;
        }
        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.steamid {
            os.write_fixed64(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() -> CDeviceAuth_GetExcludedGamesInLibrary_Request {
        CDeviceAuth_GetExcludedGamesInLibrary_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetExcludedGamesInLibrary_Request| { &m.steamid },
                |m: &mut CDeviceAuth_GetExcludedGamesInLibrary_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetExcludedGamesInLibrary_Request>(
                "CDeviceAuth_GetExcludedGamesInLibrary_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated .CDeviceAuth_GetExcludedGamesInLibrary_Response.ExcludedGame excluded_games = 1;


    pub fn get_excluded_games(&self) -> &[CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame] {
        &self.excluded_games
    }
    pub fn clear_excluded_games(&mut self) {
        self.excluded_games.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_excluded_games(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame> {
        &mut self.excluded_games
    }

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

impl ::protobuf::Message for CDeviceAuth_GetExcludedGamesInLibrary_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.excluded_games {
            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.excluded_games)?;
                },
                _ => {
                    ::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.excluded_games {
            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.excluded_games {
            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() -> CDeviceAuth_GetExcludedGamesInLibrary_Response {
        CDeviceAuth_GetExcludedGamesInLibrary_Response::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<CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame>>(
                "excluded_games",
                |m: &CDeviceAuth_GetExcludedGamesInLibrary_Response| { &m.excluded_games },
                |m: &mut CDeviceAuth_GetExcludedGamesInLibrary_Response| { &mut m.excluded_games },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetExcludedGamesInLibrary_Response>(
                "CDeviceAuth_GetExcludedGamesInLibrary_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame {
    // message fields
    appid: ::std::option::Option<u32>,
    game_name: ::protobuf::SingularField<::std::string::String>,
    vac_banned: ::std::option::Option<bool>,
    package_excluded: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


    pub fn get_appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

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

    // optional string game_name = 2;


    pub fn get_game_name(&self) -> &str {
        match self.game_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_game_name(&mut self) {
        self.game_name.clear();
    }

    pub fn has_game_name(&self) -> bool {
        self.game_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_game_name(&mut self, v: ::std::string::String) {
        self.game_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_game_name(&mut self) -> &mut ::std::string::String {
        if self.game_name.is_none() {
            self.game_name.set_default();
        }
        self.game_name.as_mut().unwrap()
    }

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

    // optional bool vac_banned = 3;


    pub fn get_vac_banned(&self) -> bool {
        self.vac_banned.unwrap_or(false)
    }
    pub fn clear_vac_banned(&mut self) {
        self.vac_banned = ::std::option::Option::None;
    }

    pub fn has_vac_banned(&self) -> bool {
        self.vac_banned.is_some()
    }

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

    // optional bool package_excluded = 4;


    pub fn get_package_excluded(&self) -> bool {
        self.package_excluded.unwrap_or(false)
    }
    pub fn clear_package_excluded(&mut self) {
        self.package_excluded = ::std::option::Option::None;
    }

    pub fn has_package_excluded(&self) -> bool {
        self.package_excluded.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame {
    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.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.game_name)?;
                },
                3 => {
                    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.vac_banned = ::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_bool()?;
                    self.package_excluded = ::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.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.game_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.vac_banned {
            my_size += 2;
        }
        if let Some(v) = self.package_excluded {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.game_name.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.vac_banned {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.package_excluded {
            os.write_bool(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() -> CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame {
        CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame::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>(
                "appid",
                |m: &CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &m.appid },
                |m: &mut CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "game_name",
                |m: &CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &m.game_name },
                |m: &mut CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &mut m.game_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "vac_banned",
                |m: &CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &m.vac_banned },
                |m: &mut CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &mut m.vac_banned },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "package_excluded",
                |m: &CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &m.package_excluded },
                |m: &mut CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame| { &mut m.package_excluded },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame>(
                "CDeviceAuth_GetExcludedGamesInLibrary_Response.ExcludedGame",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetExcludedGamesInLibrary_Response_ExcludedGame {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.game_name.clear();
        self.vac_banned = ::std::option::Option::None;
        self.package_excluded = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetBorrowerPlayHistory_Request {
    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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::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.steamid {
            my_size += 9;
        }
        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.steamid {
            os.write_fixed64(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() -> CDeviceAuth_GetBorrowerPlayHistory_Request {
        CDeviceAuth_GetBorrowerPlayHistory_Request::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Request| { &m.steamid },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetBorrowerPlayHistory_Request>(
                "CDeviceAuth_GetBorrowerPlayHistory_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated .CDeviceAuth_GetBorrowerPlayHistory_Response.LenderHistory lender_history = 1;


    pub fn get_lender_history(&self) -> &[CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory] {
        &self.lender_history
    }
    pub fn clear_lender_history(&mut self) {
        self.lender_history.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_lender_history(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory> {
        &mut self.lender_history
    }

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

impl ::protobuf::Message for CDeviceAuth_GetBorrowerPlayHistory_Response {
    fn is_initialized(&self) -> bool {
        for v in &self.lender_history {
            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.lender_history)?;
                },
                _ => {
                    ::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.lender_history {
            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.lender_history {
            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() -> CDeviceAuth_GetBorrowerPlayHistory_Response {
        CDeviceAuth_GetBorrowerPlayHistory_Response::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<CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory>>(
                "lender_history",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Response| { &m.lender_history },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Response| { &mut m.lender_history },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetBorrowerPlayHistory_Response>(
                "CDeviceAuth_GetBorrowerPlayHistory_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional uint32 appid = 1;


    pub fn get_appid(&self) -> u32 {
        self.appid.unwrap_or(0)
    }
    pub fn clear_appid(&mut self) {
        self.appid = ::std::option::Option::None;
    }

    pub fn has_appid(&self) -> bool {
        self.appid.is_some()
    }

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

    // optional uint32 time_last = 2;


    pub fn get_time_last(&self) -> u32 {
        self.time_last.unwrap_or(0)
    }
    pub fn clear_time_last(&mut self) {
        self.time_last = ::std::option::Option::None;
    }

    pub fn has_time_last(&self) -> bool {
        self.time_last.is_some()
    }

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

    // optional uint32 time_total = 3;


    pub fn get_time_total(&self) -> u32 {
        self.time_total.unwrap_or(0)
    }
    pub fn clear_time_total(&mut self) {
        self.time_total = ::std::option::Option::None;
    }

    pub fn has_time_total(&self) -> bool {
        self.time_total.is_some()
    }

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

impl ::protobuf::Message for CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory {
    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.appid = ::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.time_last = ::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.time_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.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.time_last {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.time_total {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.time_last {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.time_total {
            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() -> CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory {
        CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory::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>(
                "appid",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory| { &m.appid },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time_last",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory| { &m.time_last },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory| { &mut m.time_last },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time_total",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory| { &m.time_total },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory| { &mut m.time_total },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory>(
                "CDeviceAuth_GetBorrowerPlayHistory_Response.GameHistory",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.time_last = ::std::option::Option::None;
        self.time_total = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory {
    // message fields
    steamid: ::std::option::Option<u64>,
    pub game_history: ::protobuf::RepeatedField<CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


    pub fn get_steamid(&self) -> u64 {
        self.steamid.unwrap_or(0)
    }
    pub fn clear_steamid(&mut self) {
        self.steamid = ::std::option::Option::None;
    }

    pub fn has_steamid(&self) -> bool {
        self.steamid.is_some()
    }

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

    // repeated .CDeviceAuth_GetBorrowerPlayHistory_Response.GameHistory game_history = 2;


    pub fn get_game_history(&self) -> &[CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory] {
        &self.game_history
    }
    pub fn clear_game_history(&mut self) {
        self.game_history.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_game_history(&mut self) -> &mut ::protobuf::RepeatedField<CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory> {
        &mut self.game_history
    }

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

impl ::protobuf::Message for CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory {
    fn is_initialized(&self) -> bool {
        for v in &self.game_history {
            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::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.game_history)?;
                },
                _ => {
                    ::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.steamid {
            my_size += 9;
        }
        for value in &self.game_history {
            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<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        for v in &self.game_history {
            os.write_tag(2, ::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() -> CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory {
        CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory::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::ProtobufTypeFixed64>(
                "steamid",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory| { &m.steamid },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CDeviceAuth_GetBorrowerPlayHistory_Response_GameHistory>>(
                "game_history",
                |m: &CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory| { &m.game_history },
                |m: &mut CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory| { &mut m.game_history },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CDeviceAuth_GetBorrowerPlayHistory_Response_LenderHistory>(
                "CDeviceAuth_GetBorrowerPlayHistory_Response.LenderHistory",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n*steammessages_deviceauth.steamclient.proto\x1a,steammessages_unified_\
    base.steamclient.proto\"r\n+CDeviceAuth_GetOwnAuthorizedDevices_Request\
    \x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12)\n\x10include\
    _canceled\x18\x02\x20\x01(\x08R\x0fincludeCanceled\"\xad\x03\n,CDeviceAu\
    th_GetOwnAuthorizedDevices_Response\x12N\n\x07devices\x18\x01\x20\x03(\
    \x0b24.CDeviceAuth_GetOwnAuthorizedDevices_Response.DeviceR\x07devices\
    \x1a\xac\x02\n\x06Device\x12*\n\x11auth_device_token\x18\x01\x20\x01(\
    \x06R\x0fauthDeviceToken\x12\x1f\n\x0bdevice_name\x18\x02\x20\x01(\tR\nd\
    eviceName\x12\x1d\n\nis_pending\x18\x03\x20\x01(\x08R\tisPending\x12\x1f\
    \n\x0bis_canceled\x18\x04\x20\x01(\x08R\nisCanceled\x12$\n\x0elast_time_\
    used\x18\x05\x20\x01(\rR\x0clastTimeUsed\x12(\n\x10last_borrower_id\x18\
    \x06\x20\x01(\x06R\x0elastBorrowerId\x12&\n\x0flast_app_played\x18\x07\
    \x20\x01(\rR\rlastAppPlayed\x12\x1d\n\nis_limited\x18\x08\x20\x01(\x08R\
    \tisLimited\"\xb6\x01\n.CDeviceAuth_AcceptAuthorizationRequest_Request\
    \x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12*\n\x11auth_de\
    vice_token\x18\x02\x20\x01(\x06R\x0fauthDeviceToken\x12\x1b\n\tauth_code\
    \x18\x03\x20\x01(\x06R\x08authCode\x12!\n\x0cfrom_steamid\x18\x04\x20\
    \x01(\x06R\x0bfromSteamid\"1\n/CDeviceAuth_AcceptAuthorizationRequest_Re\
    sponse\"q\n)CDeviceAuth_AuthorizeRemoteDevice_Request\x12\x18\n\x07steam\
    id\x18\x01\x20\x01(\x06R\x07steamid\x12*\n\x11auth_device_token\x18\x02\
    \x20\x01(\x06R\x0fauthDeviceToken\",\n*CDeviceAuth_AuthorizeRemoteDevice\
    _Response\"s\n+CDeviceAuth_DeauthorizeRemoteDevice_Request\x12\x18\n\x07\
    steamid\x18\x01\x20\x01(\x06R\x07steamid\x12*\n\x11auth_device_token\x18\
    \x02\x20\x01(\x06R\x0fauthDeviceToken\".\n,CDeviceAuth_DeauthorizeRemote\
    Device_Response\"H\n,CDeviceAuth_GetUsedAuthorizedDevices_Request\x12\
    \x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\"\xcb\x02\n-CDeviceAu\
    th_GetUsedAuthorizedDevices_Response\x12O\n\x07devices\x18\x01\x20\x03(\
    \x0b25.CDeviceAuth_GetUsedAuthorizedDevices_Response.DeviceR\x07devices\
    \x1a\xc8\x01\n\x06Device\x12*\n\x11auth_device_token\x18\x01\x20\x01(\
    \x06R\x0fauthDeviceToken\x12\x1f\n\x0bdevice_name\x18\x02\x20\x01(\tR\nd\
    eviceName\x12#\n\rowner_steamid\x18\x03\x20\x01(\x06R\x0cownerSteamid\
    \x12$\n\x0elast_time_used\x18\x04\x20\x01(\rR\x0clastTimeUsed\x12&\n\x0f\
    last_app_played\x18\x05\x20\x01(\rR\rlastAppPlayed\"\x9a\x01\n*CDeviceAu\
    th_GetAuthorizedBorrowers_Request\x12\x18\n\x07steamid\x18\x01\x20\x01(\
    \x06R\x07steamid\x12)\n\x10include_canceled\x18\x02\x20\x01(\x08R\x0finc\
    ludeCanceled\x12'\n\x0finclude_pending\x18\x03\x20\x01(\x08R\x0eincludeP\
    ending\"\x8c\x02\n+CDeviceAuth_GetAuthorizedBorrowers_Response\x12S\n\tb\
    orrowers\x18\x01\x20\x03(\x0b25.CDeviceAuth_GetAuthorizedBorrowers_Respo\
    nse.BorrowerR\tborrowers\x1a\x87\x01\n\x08Borrower\x12\x18\n\x07steamid\
    \x18\x01\x20\x01(\x06R\x07steamid\x12\x1d\n\nis_pending\x18\x02\x20\x01(\
    \x08R\tisPending\x12\x1f\n\x0bis_canceled\x18\x03\x20\x01(\x08R\nisCance\
    led\x12!\n\x0ctime_created\x18\x04\x20\x01(\rR\x0btimeCreated\"q\n*CDevi\
    ceAuth_AddAuthorizedBorrowers_Request\x12\x18\n\x07steamid\x18\x01\x20\
    \x01(\x06R\x07steamid\x12)\n\x10steamid_borrower\x18\x02\x20\x03(\x06R\
    \x0fsteamidBorrower\"U\n+CDeviceAuth_AddAuthorizedBorrowers_Response\x12\
    &\n\x0fseconds_to_wait\x18\x01\x20\x01(\x05R\rsecondsToWait\"t\n-CDevice\
    Auth_RemoveAuthorizedBorrowers_Request\x12\x18\n\x07steamid\x18\x01\x20\
    \x01(\x06R\x07steamid\x12)\n\x10steamid_borrower\x18\x02\x20\x03(\x06R\
    \x0fsteamidBorrower\"0\n.CDeviceAuth_RemoveAuthorizedBorrowers_Response\
    \"\x9b\x01\n+CDeviceAuth_GetAuthorizedAsBorrower_Request\x12\x18\n\x07st\
    eamid\x18\x01\x20\x01(\x06R\x07steamid\x12)\n\x10include_canceled\x18\
    \x02\x20\x01(\x08R\x0fincludeCanceled\x12'\n\x0finclude_pending\x18\x03\
    \x20\x01(\x08R\x0eincludePending\"\x9f\x02\n,CDeviceAuth_GetAuthorizedAs\
    Borrower_Response\x12N\n\x07lenders\x18\x01\x20\x03(\x0b24.CDeviceAuth_G\
    etAuthorizedAsBorrower_Response.LenderR\x07lenders\x1a\x9e\x01\n\x06Lend\
    er\x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12!\n\x0ctime_\
    created\x18\x02\x20\x01(\rR\x0btimeCreated\x12\x1d\n\nis_pending\x18\x03\
    \x20\x01(\x08R\tisPending\x12\x1f\n\x0bis_canceled\x18\x04\x20\x01(\x08R\
    \nisCanceled\x12\x17\n\x07is_used\x18\x05\x20\x01(\x08R\x06isUsed\"I\n-C\
    DeviceAuth_GetExcludedGamesInLibrary_Request\x12\x18\n\x07steamid\x18\
    \x01\x20\x01(\x06R\x07steamid\"\xa3\x02\n.CDeviceAuth_GetExcludedGamesIn\
    Library_Response\x12c\n\x0eexcluded_games\x18\x01\x20\x03(\x0b2<.CDevice\
    Auth_GetExcludedGamesInLibrary_Response.ExcludedGameR\rexcludedGames\x1a\
    \x8b\x01\n\x0cExcludedGame\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05app\
    id\x12\x1b\n\tgame_name\x18\x02\x20\x01(\tR\x08gameName\x12\x1d\n\nvac_b\
    anned\x18\x03\x20\x01(\x08R\tvacBanned\x12)\n\x10package_excluded\x18\
    \x04\x20\x01(\x08R\x0fpackageExcluded\"F\n*CDeviceAuth_GetBorrowerPlayHi\
    story_Request\x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\"\
    \xfa\x02\n+CDeviceAuth_GetBorrowerPlayHistory_Response\x12a\n\x0elender_\
    history\x18\x01\x20\x03(\x0b2:.CDeviceAuth_GetBorrowerPlayHistory_Respon\
    se.LenderHistoryR\rlenderHistory\x1a_\n\x0bGameHistory\x12\x14\n\x05appi\
    d\x18\x01\x20\x01(\rR\x05appid\x12\x1b\n\ttime_last\x18\x02\x20\x01(\rR\
    \x08timeLast\x12\x1d\n\ntime_total\x18\x03\x20\x01(\rR\ttimeTotal\x1a\
    \x86\x01\n\rLenderHistory\x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\x07\
    steamid\x12[\n\x0cgame_history\x18\x02\x20\x03(\x0b28.CDeviceAuth_GetBor\
    rowerPlayHistory_Response.GameHistoryR\x0bgameHistory2\xc2\x0f\n\nDevice\
    Auth\x12\x9a\x01\n\x17GetOwnAuthorizedDevices\x12,.CDeviceAuth_GetOwnAut\
    horizedDevices_Request\x1a-.CDeviceAuth_GetOwnAuthorizedDevices_Response\
    \"\"\x82\xb5\x18\x1eGet\x20list\x20of\x20authorized\x20devices\x12\xb5\
    \x01\n\x1aAcceptAuthorizationRequest\x12/.CDeviceAuth_AcceptAuthorizatio\
    nRequest_Request\x1a0.CDeviceAuth_AcceptAuthorizationRequest_Response\"4\
    \x82\xb5\x180Accept\x20an\x20authorization\x20request\x20by\x20another\
    \x20users\x12\xaa\x01\n\x15AuthorizeRemoteDevice\x12*.CDeviceAuth_Author\
    izeRemoteDevice_Request\x1a+.CDeviceAuth_AuthorizeRemoteDevice_Response\
    \"8\x82\xb5\x184Authorize\x20own\x20remote\x20device\x20that\x20has\x20p\
    ending\x20request\x12\x9b\x01\n\x17DeauthorizeRemoteDevice\x12,.CDeviceA\
    uth_DeauthorizeRemoteDevice_Request\x1a-.CDeviceAuth_DeauthorizeRemoteDe\
    vice_Response\"#\x82\xb5\x18\x1fRevoke\x20own\x20device\x20authorization\
    \x12\xbb\x01\n\x18GetUsedAuthorizedDevices\x12-.CDeviceAuth_GetUsedAutho\
    rizedDevices_Request\x1a..CDeviceAuth_GetUsedAuthorizedDevices_Response\
    \"@\x82\xb5\x18<Get\x20list\x20of\x20authorized\x20devices\x20user\x20pl\
    ayed\x20borrowed\x20games\x20on\x12\xb2\x01\n\x16GetAuthorizedBorrowers\
    \x12+.CDeviceAuth_GetAuthorizedBorrowers_Request\x1a,.CDeviceAuth_GetAut\
    horizedBorrowers_Response\"=\x82\xb5\x189Get\x20list\x20of\x20users\x20t\
    hat\x20can\x20borrow\x20on\x20an\x20authorized\x20device\x12\xb0\x01\n\
    \x16AddAuthorizedBorrowers\x12+.CDeviceAuth_AddAuthorizedBorrowers_Reque\
    st\x1a,.CDeviceAuth_AddAuthorizedBorrowers_Response\";\x82\xb5\x187Add\
    \x20users\x20that\x20can\x20borrow\x20on\x20limited\x20authorized\x20dev\
    ices\x12\xbc\x01\n\x19RemoveAuthorizedBorrowers\x12..CDeviceAuth_RemoveA\
    uthorizedBorrowers_Request\x1a/.CDeviceAuth_RemoveAuthorizedBorrowers_Re\
    sponse\">\x82\xb5\x18:Remove\x20users\x20that\x20can\x20borrow\x20on\x20\
    limited\x20authorized\x20devices\x12\xb9\x01\n\x17GetAuthorizedAsBorrowe\
    r\x12,.CDeviceAuth_GetAuthorizedAsBorrower_Request\x1a-.CDeviceAuth_GetA\
    uthorizedAsBorrower_Response\"A\x82\xb5\x18=Get\x20list\x20of\x20lenders\
    \x20that\x20authorized\x20given\x20account\x20as\x20borrower\x12\xaf\x01\
    \n\x19GetExcludedGamesInLibrary\x12..CDeviceAuth_GetExcludedGamesInLibra\
    ry_Request\x1a/.CDeviceAuth_GetExcludedGamesInLibrary_Response\"1\x82\
    \xb5\x18-Get\x20list\x20of\x20excluded\x20games\x20in\x20lenders\x20libr\
    ary\x12\x9a\x01\n\x16GetBorrowerPlayHistory\x12+.CDeviceAuth_GetBorrower\
    PlayHistory_Request\x1a,.CDeviceAuth_GetBorrowerPlayHistory_Response\"%\
    \x82\xb5\x18!Get\x20list\x20played\x20games\x20as\x20borrower\x1a$\x82\
    \xb5\x18\x20Library\x20Sharing\x20settings\x20serviceB\x03\x80\x01\x01J\
    \xa72\n\x07\x12\x05\0\0\xc6\x01\x01\n\t\n\x02\x03\0\x12\x03\0\06\n\x08\n\
    \x01\x08\x12\x03\x02\0\"\n\t\n\x02\x08\x10\x12\x03\x02\0\"\n\n\n\x02\x04\
    \0\x12\x04\x04\0\x07\x01\n\n\n\x03\x04\0\x01\x12\x03\x04\x083\n\x0b\n\
    \x04\x04\0\x02\0\x12\x03\x05\x08%\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\
    \x05\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x05\x11\x18\n\x0c\n\x05\
    \x04\0\x02\0\x01\x12\x03\x05\x19\x20\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\
    \x05#$\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x06\x08+\n\x0c\n\x05\x04\0\x02\
    \x01\x04\x12\x03\x06\x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x06\
    \x11\x15\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x06\x16&\n\x0c\n\x05\x04\
    \0\x02\x01\x03\x12\x03\x06)*\n\n\n\x02\x04\x01\x12\x04\t\0\x16\x01\n\n\n\
    \x03\x04\x01\x01\x12\x03\t\x084\n\x0c\n\x04\x04\x01\x03\0\x12\x04\n\x08\
    \x13\t\n\x0c\n\x05\x04\x01\x03\0\x01\x12\x03\n\x10\x16\n\r\n\x06\x04\x01\
    \x03\0\x02\0\x12\x03\x0b\x107\n\x0e\n\x07\x04\x01\x03\0\x02\0\x04\x12\
    \x03\x0b\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\0\x05\x12\x03\x0b\x19\x20\
    \n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\x12\x03\x0b!2\n\x0e\n\x07\x04\x01\
    \x03\0\x02\0\x03\x12\x03\x0b56\n\r\n\x06\x04\x01\x03\0\x02\x01\x12\x03\
    \x0c\x100\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x04\x12\x03\x0c\x10\x18\n\
    \x0e\n\x07\x04\x01\x03\0\x02\x01\x05\x12\x03\x0c\x19\x1f\n\x0e\n\x07\x04\
    \x01\x03\0\x02\x01\x01\x12\x03\x0c\x20+\n\x0e\n\x07\x04\x01\x03\0\x02\
    \x01\x03\x12\x03\x0c./\n\r\n\x06\x04\x01\x03\0\x02\x02\x12\x03\r\x10-\n\
    \x0e\n\x07\x04\x01\x03\0\x02\x02\x04\x12\x03\r\x10\x18\n\x0e\n\x07\x04\
    \x01\x03\0\x02\x02\x05\x12\x03\r\x19\x1d\n\x0e\n\x07\x04\x01\x03\0\x02\
    \x02\x01\x12\x03\r\x1e(\n\x0e\n\x07\x04\x01\x03\0\x02\x02\x03\x12\x03\r+\
    ,\n\r\n\x06\x04\x01\x03\0\x02\x03\x12\x03\x0e\x10.\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x03\x04\x12\x03\x0e\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x03\
    \x05\x12\x03\x0e\x19\x1d\n\x0e\n\x07\x04\x01\x03\0\x02\x03\x01\x12\x03\
    \x0e\x1e)\n\x0e\n\x07\x04\x01\x03\0\x02\x03\x03\x12\x03\x0e,-\n\r\n\x06\
    \x04\x01\x03\0\x02\x04\x12\x03\x0f\x103\n\x0e\n\x07\x04\x01\x03\0\x02\
    \x04\x04\x12\x03\x0f\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x04\x05\x12\
    \x03\x0f\x19\x1f\n\x0e\n\x07\x04\x01\x03\0\x02\x04\x01\x12\x03\x0f\x20.\
    \n\x0e\n\x07\x04\x01\x03\0\x02\x04\x03\x12\x03\x0f12\n\r\n\x06\x04\x01\
    \x03\0\x02\x05\x12\x03\x10\x106\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x04\
    \x12\x03\x10\x10\x18\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x05\x12\x03\x10\
    \x19\x20\n\x0e\n\x07\x04\x01\x03\0\x02\x05\x01\x12\x03\x10!1\n\x0e\n\x07\
    \x04\x01\x03\0\x02\x05\x03\x12\x03\x1045\n\r\n\x06\x04\x01\x03\0\x02\x06\
    \x12\x03\x11\x104\n\x0e\n\x07\x04\x01\x03\0\x02\x06\x04\x12\x03\x11\x10\
    \x18\n\x0e\n\x07\x04\x01\x03\0\x02\x06\x05\x12\x03\x11\x19\x1f\n\x0e\n\
    \x07\x04\x01\x03\0\x02\x06\x01\x12\x03\x11\x20/\n\x0e\n\x07\x04\x01\x03\
    \0\x02\x06\x03\x12\x03\x1123\n\r\n\x06\x04\x01\x03\0\x02\x07\x12\x03\x12\
    \x10-\n\x0e\n\x07\x04\x01\x03\0\x02\x07\x04\x12\x03\x12\x10\x18\n\x0e\n\
    \x07\x04\x01\x03\0\x02\x07\x05\x12\x03\x12\x19\x1d\n\x0e\n\x07\x04\x01\
    \x03\0\x02\x07\x01\x12\x03\x12\x1e(\n\x0e\n\x07\x04\x01\x03\0\x02\x07\
    \x03\x12\x03\x12+,\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x15\x08R\n\x0c\n\
    \x05\x04\x01\x02\0\x04\x12\x03\x15\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x06\
    \x12\x03\x15\x11E\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x15FM\n\x0c\n\
    \x05\x04\x01\x02\0\x03\x12\x03\x15PQ\n\n\n\x02\x04\x02\x12\x04\x18\0\x1d\
    \x01\n\n\n\x03\x04\x02\x01\x12\x03\x18\x086\n\x0b\n\x04\x04\x02\x02\0\
    \x12\x03\x19\x08%\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\x19\x08\x10\n\
    \x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x19\x11\x18\n\x0c\n\x05\x04\x02\x02\
    \0\x01\x12\x03\x19\x19\x20\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x19#$\n\
    \x0b\n\x04\x04\x02\x02\x01\x12\x03\x1a\x08/\n\x0c\n\x05\x04\x02\x02\x01\
    \x04\x12\x03\x1a\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03\x1a\x11\
    \x18\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x1a\x19*\n\x0c\n\x05\x04\
    \x02\x02\x01\x03\x12\x03\x1a-.\n\x0b\n\x04\x04\x02\x02\x02\x12\x03\x1b\
    \x08'\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x03\x1b\x08\x10\n\x0c\n\x05\
    \x04\x02\x02\x02\x05\x12\x03\x1b\x11\x18\n\x0c\n\x05\x04\x02\x02\x02\x01\
    \x12\x03\x1b\x19\"\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03\x1b%&\n\x0b\n\
    \x04\x04\x02\x02\x03\x12\x03\x1c\x08*\n\x0c\n\x05\x04\x02\x02\x03\x04\
    \x12\x03\x1c\x08\x10\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x03\x1c\x11\x18\
    \n\x0c\n\x05\x04\x02\x02\x03\x01\x12\x03\x1c\x19%\n\x0c\n\x05\x04\x02\
    \x02\x03\x03\x12\x03\x1c()\n\n\n\x02\x04\x03\x12\x04\x1f\0\x20\x01\n\n\n\
    \x03\x04\x03\x01\x12\x03\x1f\x087\n\n\n\x02\x04\x04\x12\x04\"\0%\x01\n\n\
    \n\x03\x04\x04\x01\x12\x03\"\x081\n\x0b\n\x04\x04\x04\x02\0\x12\x03#\x08\
    %\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03#\x08\x10\n\x0c\n\x05\x04\x04\x02\
    \0\x05\x12\x03#\x11\x18\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03#\x19\x20\n\
    \x0c\n\x05\x04\x04\x02\0\x03\x12\x03##$\n\x0b\n\x04\x04\x04\x02\x01\x12\
    \x03$\x08/\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03$\x08\x10\n\x0c\n\x05\
    \x04\x04\x02\x01\x05\x12\x03$\x11\x18\n\x0c\n\x05\x04\x04\x02\x01\x01\
    \x12\x03$\x19*\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03$-.\n\n\n\x02\x04\
    \x05\x12\x04'\0(\x01\n\n\n\x03\x04\x05\x01\x12\x03'\x082\n\n\n\x02\x04\
    \x06\x12\x04*\0-\x01\n\n\n\x03\x04\x06\x01\x12\x03*\x083\n\x0b\n\x04\x04\
    \x06\x02\0\x12\x03+\x08%\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03+\x08\x10\
    \n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03+\x11\x18\n\x0c\n\x05\x04\x06\x02\
    \0\x01\x12\x03+\x19\x20\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03+#$\n\x0b\n\
    \x04\x04\x06\x02\x01\x12\x03,\x08/\n\x0c\n\x05\x04\x06\x02\x01\x04\x12\
    \x03,\x08\x10\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03,\x11\x18\n\x0c\n\
    \x05\x04\x06\x02\x01\x01\x12\x03,\x19*\n\x0c\n\x05\x04\x06\x02\x01\x03\
    \x12\x03,-.\n\n\n\x02\x04\x07\x12\x04/\00\x01\n\n\n\x03\x04\x07\x01\x12\
    \x03/\x084\n\n\n\x02\x04\x08\x12\x042\04\x01\n\n\n\x03\x04\x08\x01\x12\
    \x032\x084\n\x0b\n\x04\x04\x08\x02\0\x12\x033\x08%\n\x0c\n\x05\x04\x08\
    \x02\0\x04\x12\x033\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x033\x11\
    \x18\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x033\x19\x20\n\x0c\n\x05\x04\x08\
    \x02\0\x03\x12\x033#$\n\n\n\x02\x04\t\x12\x046\0@\x01\n\n\n\x03\x04\t\
    \x01\x12\x036\x085\n\x0c\n\x04\x04\t\x03\0\x12\x047\x08=\t\n\x0c\n\x05\
    \x04\t\x03\0\x01\x12\x037\x10\x16\n\r\n\x06\x04\t\x03\0\x02\0\x12\x038\
    \x107\n\x0e\n\x07\x04\t\x03\0\x02\0\x04\x12\x038\x10\x18\n\x0e\n\x07\x04\
    \t\x03\0\x02\0\x05\x12\x038\x19\x20\n\x0e\n\x07\x04\t\x03\0\x02\0\x01\
    \x12\x038!2\n\x0e\n\x07\x04\t\x03\0\x02\0\x03\x12\x03856\n\r\n\x06\x04\t\
    \x03\0\x02\x01\x12\x039\x100\n\x0e\n\x07\x04\t\x03\0\x02\x01\x04\x12\x03\
    9\x10\x18\n\x0e\n\x07\x04\t\x03\0\x02\x01\x05\x12\x039\x19\x1f\n\x0e\n\
    \x07\x04\t\x03\0\x02\x01\x01\x12\x039\x20+\n\x0e\n\x07\x04\t\x03\0\x02\
    \x01\x03\x12\x039./\n\r\n\x06\x04\t\x03\0\x02\x02\x12\x03:\x103\n\x0e\n\
    \x07\x04\t\x03\0\x02\x02\x04\x12\x03:\x10\x18\n\x0e\n\x07\x04\t\x03\0\
    \x02\x02\x05\x12\x03:\x19\x20\n\x0e\n\x07\x04\t\x03\0\x02\x02\x01\x12\
    \x03:!.\n\x0e\n\x07\x04\t\x03\0\x02\x02\x03\x12\x03:12\n\r\n\x06\x04\t\
    \x03\0\x02\x03\x12\x03;\x103\n\x0e\n\x07\x04\t\x03\0\x02\x03\x04\x12\x03\
    ;\x10\x18\n\x0e\n\x07\x04\t\x03\0\x02\x03\x05\x12\x03;\x19\x1f\n\x0e\n\
    \x07\x04\t\x03\0\x02\x03\x01\x12\x03;\x20.\n\x0e\n\x07\x04\t\x03\0\x02\
    \x03\x03\x12\x03;12\n\r\n\x06\x04\t\x03\0\x02\x04\x12\x03<\x104\n\x0e\n\
    \x07\x04\t\x03\0\x02\x04\x04\x12\x03<\x10\x18\n\x0e\n\x07\x04\t\x03\0\
    \x02\x04\x05\x12\x03<\x19\x1f\n\x0e\n\x07\x04\t\x03\0\x02\x04\x01\x12\
    \x03<\x20/\n\x0e\n\x07\x04\t\x03\0\x02\x04\x03\x12\x03<23\n\x0b\n\x04\
    \x04\t\x02\0\x12\x03?\x08S\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03?\x08\x10\
    \n\x0c\n\x05\x04\t\x02\0\x06\x12\x03?\x11F\n\x0c\n\x05\x04\t\x02\0\x01\
    \x12\x03?GN\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03?QR\n\n\n\x02\x04\n\x12\
    \x04B\0F\x01\n\n\n\x03\x04\n\x01\x12\x03B\x082\n\x0b\n\x04\x04\n\x02\0\
    \x12\x03C\x08%\n\x0c\n\x05\x04\n\x02\0\x04\x12\x03C\x08\x10\n\x0c\n\x05\
    \x04\n\x02\0\x05\x12\x03C\x11\x18\n\x0c\n\x05\x04\n\x02\0\x01\x12\x03C\
    \x19\x20\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03C#$\n\x0b\n\x04\x04\n\x02\
    \x01\x12\x03D\x08+\n\x0c\n\x05\x04\n\x02\x01\x04\x12\x03D\x08\x10\n\x0c\
    \n\x05\x04\n\x02\x01\x05\x12\x03D\x11\x15\n\x0c\n\x05\x04\n\x02\x01\x01\
    \x12\x03D\x16&\n\x0c\n\x05\x04\n\x02\x01\x03\x12\x03D)*\n\x0b\n\x04\x04\
    \n\x02\x02\x12\x03E\x08*\n\x0c\n\x05\x04\n\x02\x02\x04\x12\x03E\x08\x10\
    \n\x0c\n\x05\x04\n\x02\x02\x05\x12\x03E\x11\x15\n\x0c\n\x05\x04\n\x02\
    \x02\x01\x12\x03E\x16%\n\x0c\n\x05\x04\n\x02\x02\x03\x12\x03E()\n\n\n\
    \x02\x04\x0b\x12\x04H\0Q\x01\n\n\n\x03\x04\x0b\x01\x12\x03H\x083\n\x0c\n\
    \x04\x04\x0b\x03\0\x12\x04I\x08N\t\n\x0c\n\x05\x04\x0b\x03\0\x01\x12\x03\
    I\x10\x18\n\r\n\x06\x04\x0b\x03\0\x02\0\x12\x03J\x10-\n\x0e\n\x07\x04\
    \x0b\x03\0\x02\0\x04\x12\x03J\x10\x18\n\x0e\n\x07\x04\x0b\x03\0\x02\0\
    \x05\x12\x03J\x19\x20\n\x0e\n\x07\x04\x0b\x03\0\x02\0\x01\x12\x03J!(\n\
    \x0e\n\x07\x04\x0b\x03\0\x02\0\x03\x12\x03J+,\n\r\n\x06\x04\x0b\x03\0\
    \x02\x01\x12\x03K\x10-\n\x0e\n\x07\x04\x0b\x03\0\x02\x01\x04\x12\x03K\
    \x10\x18\n\x0e\n\x07\x04\x0b\x03\0\x02\x01\x05\x12\x03K\x19\x1d\n\x0e\n\
    \x07\x04\x0b\x03\0\x02\x01\x01\x12\x03K\x1e(\n\x0e\n\x07\x04\x0b\x03\0\
    \x02\x01\x03\x12\x03K+,\n\r\n\x06\x04\x0b\x03\0\x02\x02\x12\x03L\x10.\n\
    \x0e\n\x07\x04\x0b\x03\0\x02\x02\x04\x12\x03L\x10\x18\n\x0e\n\x07\x04\
    \x0b\x03\0\x02\x02\x05\x12\x03L\x19\x1d\n\x0e\n\x07\x04\x0b\x03\0\x02\
    \x02\x01\x12\x03L\x1e)\n\x0e\n\x07\x04\x0b\x03\0\x02\x02\x03\x12\x03L,-\
    \n\r\n\x06\x04\x0b\x03\0\x02\x03\x12\x03M\x101\n\x0e\n\x07\x04\x0b\x03\0\
    \x02\x03\x04\x12\x03M\x10\x18\n\x0e\n\x07\x04\x0b\x03\0\x02\x03\x05\x12\
    \x03M\x19\x1f\n\x0e\n\x07\x04\x0b\x03\0\x02\x03\x01\x12\x03M\x20,\n\x0e\
    \n\x07\x04\x0b\x03\0\x02\x03\x03\x12\x03M/0\n\x0b\n\x04\x04\x0b\x02\0\
    \x12\x03P\x08U\n\x0c\n\x05\x04\x0b\x02\0\x04\x12\x03P\x08\x10\n\x0c\n\
    \x05\x04\x0b\x02\0\x06\x12\x03P\x11F\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\
    \x03PGP\n\x0c\n\x05\x04\x0b\x02\0\x03\x12\x03PST\n\n\n\x02\x04\x0c\x12\
    \x04S\0V\x01\n\n\n\x03\x04\x0c\x01\x12\x03S\x082\n\x0b\n\x04\x04\x0c\x02\
    \0\x12\x03T\x08%\n\x0c\n\x05\x04\x0c\x02\0\x04\x12\x03T\x08\x10\n\x0c\n\
    \x05\x04\x0c\x02\0\x05\x12\x03T\x11\x18\n\x0c\n\x05\x04\x0c\x02\0\x01\
    \x12\x03T\x19\x20\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03T#$\n\x0b\n\x04\
    \x04\x0c\x02\x01\x12\x03U\x08.\n\x0c\n\x05\x04\x0c\x02\x01\x04\x12\x03U\
    \x08\x10\n\x0c\n\x05\x04\x0c\x02\x01\x05\x12\x03U\x11\x18\n\x0c\n\x05\
    \x04\x0c\x02\x01\x01\x12\x03U\x19)\n\x0c\n\x05\x04\x0c\x02\x01\x03\x12\
    \x03U,-\n\n\n\x02\x04\r\x12\x04X\0Z\x01\n\n\n\x03\x04\r\x01\x12\x03X\x08\
    3\n\x0b\n\x04\x04\r\x02\0\x12\x03Y\x08+\n\x0c\n\x05\x04\r\x02\0\x04\x12\
    \x03Y\x08\x10\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03Y\x11\x16\n\x0c\n\x05\
    \x04\r\x02\0\x01\x12\x03Y\x17&\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03Y)*\n\
    \n\n\x02\x04\x0e\x12\x04\\\0_\x01\n\n\n\x03\x04\x0e\x01\x12\x03\\\x085\n\
    \x0b\n\x04\x04\x0e\x02\0\x12\x03]\x08%\n\x0c\n\x05\x04\x0e\x02\0\x04\x12\
    \x03]\x08\x10\n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03]\x11\x18\n\x0c\n\x05\
    \x04\x0e\x02\0\x01\x12\x03]\x19\x20\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\
    \x03]#$\n\x0b\n\x04\x04\x0e\x02\x01\x12\x03^\x08.\n\x0c\n\x05\x04\x0e\
    \x02\x01\x04\x12\x03^\x08\x10\n\x0c\n\x05\x04\x0e\x02\x01\x05\x12\x03^\
    \x11\x18\n\x0c\n\x05\x04\x0e\x02\x01\x01\x12\x03^\x19)\n\x0c\n\x05\x04\
    \x0e\x02\x01\x03\x12\x03^,-\n\n\n\x02\x04\x0f\x12\x04a\0b\x01\n\n\n\x03\
    \x04\x0f\x01\x12\x03a\x086\n\n\n\x02\x04\x10\x12\x04d\0h\x01\n\n\n\x03\
    \x04\x10\x01\x12\x03d\x083\n\x0b\n\x04\x04\x10\x02\0\x12\x03e\x08%\n\x0c\
    \n\x05\x04\x10\x02\0\x04\x12\x03e\x08\x10\n\x0c\n\x05\x04\x10\x02\0\x05\
    \x12\x03e\x11\x18\n\x0c\n\x05\x04\x10\x02\0\x01\x12\x03e\x19\x20\n\x0c\n\
    \x05\x04\x10\x02\0\x03\x12\x03e#$\n\x0b\n\x04\x04\x10\x02\x01\x12\x03f\
    \x08+\n\x0c\n\x05\x04\x10\x02\x01\x04\x12\x03f\x08\x10\n\x0c\n\x05\x04\
    \x10\x02\x01\x05\x12\x03f\x11\x15\n\x0c\n\x05\x04\x10\x02\x01\x01\x12\
    \x03f\x16&\n\x0c\n\x05\x04\x10\x02\x01\x03\x12\x03f)*\n\x0b\n\x04\x04\
    \x10\x02\x02\x12\x03g\x08*\n\x0c\n\x05\x04\x10\x02\x02\x04\x12\x03g\x08\
    \x10\n\x0c\n\x05\x04\x10\x02\x02\x05\x12\x03g\x11\x15\n\x0c\n\x05\x04\
    \x10\x02\x02\x01\x12\x03g\x16%\n\x0c\n\x05\x04\x10\x02\x02\x03\x12\x03g(\
    )\n\n\n\x02\x04\x11\x12\x04j\0t\x01\n\n\n\x03\x04\x11\x01\x12\x03j\x084\
    \n\x0c\n\x04\x04\x11\x03\0\x12\x04k\x08q\t\n\x0c\n\x05\x04\x11\x03\0\x01\
    \x12\x03k\x10\x16\n\r\n\x06\x04\x11\x03\0\x02\0\x12\x03l\x10-\n\x0e\n\
    \x07\x04\x11\x03\0\x02\0\x04\x12\x03l\x10\x18\n\x0e\n\x07\x04\x11\x03\0\
    \x02\0\x05\x12\x03l\x19\x20\n\x0e\n\x07\x04\x11\x03\0\x02\0\x01\x12\x03l\
    !(\n\x0e\n\x07\x04\x11\x03\0\x02\0\x03\x12\x03l+,\n\r\n\x06\x04\x11\x03\
    \0\x02\x01\x12\x03m\x101\n\x0e\n\x07\x04\x11\x03\0\x02\x01\x04\x12\x03m\
    \x10\x18\n\x0e\n\x07\x04\x11\x03\0\x02\x01\x05\x12\x03m\x19\x1f\n\x0e\n\
    \x07\x04\x11\x03\0\x02\x01\x01\x12\x03m\x20,\n\x0e\n\x07\x04\x11\x03\0\
    \x02\x01\x03\x12\x03m/0\n\r\n\x06\x04\x11\x03\0\x02\x02\x12\x03n\x10-\n\
    \x0e\n\x07\x04\x11\x03\0\x02\x02\x04\x12\x03n\x10\x18\n\x0e\n\x07\x04\
    \x11\x03\0\x02\x02\x05\x12\x03n\x19\x1d\n\x0e\n\x07\x04\x11\x03\0\x02\
    \x02\x01\x12\x03n\x1e(\n\x0e\n\x07\x04\x11\x03\0\x02\x02\x03\x12\x03n+,\
    \n\r\n\x06\x04\x11\x03\0\x02\x03\x12\x03o\x10.\n\x0e\n\x07\x04\x11\x03\0\
    \x02\x03\x04\x12\x03o\x10\x18\n\x0e\n\x07\x04\x11\x03\0\x02\x03\x05\x12\
    \x03o\x19\x1d\n\x0e\n\x07\x04\x11\x03\0\x02\x03\x01\x12\x03o\x1e)\n\x0e\
    \n\x07\x04\x11\x03\0\x02\x03\x03\x12\x03o,-\n\r\n\x06\x04\x11\x03\0\x02\
    \x04\x12\x03p\x10*\n\x0e\n\x07\x04\x11\x03\0\x02\x04\x04\x12\x03p\x10\
    \x18\n\x0e\n\x07\x04\x11\x03\0\x02\x04\x05\x12\x03p\x19\x1d\n\x0e\n\x07\
    \x04\x11\x03\0\x02\x04\x01\x12\x03p\x1e%\n\x0e\n\x07\x04\x11\x03\0\x02\
    \x04\x03\x12\x03p()\n\x0b\n\x04\x04\x11\x02\0\x12\x03s\x08R\n\x0c\n\x05\
    \x04\x11\x02\0\x04\x12\x03s\x08\x10\n\x0c\n\x05\x04\x11\x02\0\x06\x12\
    \x03s\x11E\n\x0c\n\x05\x04\x11\x02\0\x01\x12\x03sFM\n\x0c\n\x05\x04\x11\
    \x02\0\x03\x12\x03sPQ\n\n\n\x02\x04\x12\x12\x04v\0x\x01\n\n\n\x03\x04\
    \x12\x01\x12\x03v\x085\n\x0b\n\x04\x04\x12\x02\0\x12\x03w\x08%\n\x0c\n\
    \x05\x04\x12\x02\0\x04\x12\x03w\x08\x10\n\x0c\n\x05\x04\x12\x02\0\x05\
    \x12\x03w\x11\x18\n\x0c\n\x05\x04\x12\x02\0\x01\x12\x03w\x19\x20\n\x0c\n\
    \x05\x04\x12\x02\0\x03\x12\x03w#$\n\x0b\n\x02\x04\x13\x12\x05z\0\x83\x01\
    \x01\n\n\n\x03\x04\x13\x01\x12\x03z\x086\n\r\n\x04\x04\x13\x03\0\x12\x05\
    {\x08\x80\x01\t\n\x0c\n\x05\x04\x13\x03\0\x01\x12\x03{\x10\x1c\n\r\n\x06\
    \x04\x13\x03\0\x02\0\x12\x03|\x10*\n\x0e\n\x07\x04\x13\x03\0\x02\0\x04\
    \x12\x03|\x10\x18\n\x0e\n\x07\x04\x13\x03\0\x02\0\x05\x12\x03|\x19\x1f\n\
    \x0e\n\x07\x04\x13\x03\0\x02\0\x01\x12\x03|\x20%\n\x0e\n\x07\x04\x13\x03\
    \0\x02\0\x03\x12\x03|()\n\r\n\x06\x04\x13\x03\0\x02\x01\x12\x03}\x10.\n\
    \x0e\n\x07\x04\x13\x03\0\x02\x01\x04\x12\x03}\x10\x18\n\x0e\n\x07\x04\
    \x13\x03\0\x02\x01\x05\x12\x03}\x19\x1f\n\x0e\n\x07\x04\x13\x03\0\x02\
    \x01\x01\x12\x03}\x20)\n\x0e\n\x07\x04\x13\x03\0\x02\x01\x03\x12\x03},-\
    \n\r\n\x06\x04\x13\x03\0\x02\x02\x12\x03~\x10-\n\x0e\n\x07\x04\x13\x03\0\
    \x02\x02\x04\x12\x03~\x10\x18\n\x0e\n\x07\x04\x13\x03\0\x02\x02\x05\x12\
    \x03~\x19\x1d\n\x0e\n\x07\x04\x13\x03\0\x02\x02\x01\x12\x03~\x1e(\n\x0e\
    \n\x07\x04\x13\x03\0\x02\x02\x03\x12\x03~+,\n\r\n\x06\x04\x13\x03\0\x02\
    \x03\x12\x03\x7f\x103\n\x0e\n\x07\x04\x13\x03\0\x02\x03\x04\x12\x03\x7f\
    \x10\x18\n\x0e\n\x07\x04\x13\x03\0\x02\x03\x05\x12\x03\x7f\x19\x1d\n\x0e\
    \n\x07\x04\x13\x03\0\x02\x03\x01\x12\x03\x7f\x1e.\n\x0e\n\x07\x04\x13\
    \x03\0\x02\x03\x03\x12\x03\x7f12\n\x0c\n\x04\x04\x13\x02\0\x12\x04\x82\
    \x01\x08a\n\r\n\x05\x04\x13\x02\0\x04\x12\x04\x82\x01\x08\x10\n\r\n\x05\
    \x04\x13\x02\0\x06\x12\x04\x82\x01\x11M\n\r\n\x05\x04\x13\x02\0\x01\x12\
    \x04\x82\x01N\\\n\r\n\x05\x04\x13\x02\0\x03\x12\x04\x82\x01_`\n\x0c\n\
    \x02\x04\x14\x12\x06\x85\x01\0\x87\x01\x01\n\x0b\n\x03\x04\x14\x01\x12\
    \x04\x85\x01\x082\n\x0c\n\x04\x04\x14\x02\0\x12\x04\x86\x01\x08%\n\r\n\
    \x05\x04\x14\x02\0\x04\x12\x04\x86\x01\x08\x10\n\r\n\x05\x04\x14\x02\0\
    \x05\x12\x04\x86\x01\x11\x18\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\x86\x01\
    \x19\x20\n\r\n\x05\x04\x14\x02\0\x03\x12\x04\x86\x01#$\n\x0c\n\x02\x04\
    \x15\x12\x06\x89\x01\0\x96\x01\x01\n\x0b\n\x03\x04\x15\x01\x12\x04\x89\
    \x01\x083\n\x0e\n\x04\x04\x15\x03\0\x12\x06\x8a\x01\x08\x8e\x01\t\n\r\n\
    \x05\x04\x15\x03\0\x01\x12\x04\x8a\x01\x10\x1b\n\x0e\n\x06\x04\x15\x03\0\
    \x02\0\x12\x04\x8b\x01\x10*\n\x0f\n\x07\x04\x15\x03\0\x02\0\x04\x12\x04\
    \x8b\x01\x10\x18\n\x0f\n\x07\x04\x15\x03\0\x02\0\x05\x12\x04\x8b\x01\x19\
    \x1f\n\x0f\n\x07\x04\x15\x03\0\x02\0\x01\x12\x04\x8b\x01\x20%\n\x0f\n\
    \x07\x04\x15\x03\0\x02\0\x03\x12\x04\x8b\x01()\n\x0e\n\x06\x04\x15\x03\0\
    \x02\x01\x12\x04\x8c\x01\x10.\n\x0f\n\x07\x04\x15\x03\0\x02\x01\x04\x12\
    \x04\x8c\x01\x10\x18\n\x0f\n\x07\x04\x15\x03\0\x02\x01\x05\x12\x04\x8c\
    \x01\x19\x1f\n\x0f\n\x07\x04\x15\x03\0\x02\x01\x01\x12\x04\x8c\x01\x20)\
    \n\x0f\n\x07\x04\x15\x03\0\x02\x01\x03\x12\x04\x8c\x01,-\n\x0e\n\x06\x04\
    \x15\x03\0\x02\x02\x12\x04\x8d\x01\x10/\n\x0f\n\x07\x04\x15\x03\0\x02\
    \x02\x04\x12\x04\x8d\x01\x10\x18\n\x0f\n\x07\x04\x15\x03\0\x02\x02\x05\
    \x12\x04\x8d\x01\x19\x1f\n\x0f\n\x07\x04\x15\x03\0\x02\x02\x01\x12\x04\
    \x8d\x01\x20*\n\x0f\n\x07\x04\x15\x03\0\x02\x02\x03\x12\x04\x8d\x01-.\n\
    \x0e\n\x04\x04\x15\x03\x01\x12\x06\x90\x01\x08\x93\x01\t\n\r\n\x05\x04\
    \x15\x03\x01\x01\x12\x04\x90\x01\x10\x1d\n\x0e\n\x06\x04\x15\x03\x01\x02\
    \0\x12\x04\x91\x01\x10-\n\x0f\n\x07\x04\x15\x03\x01\x02\0\x04\x12\x04\
    \x91\x01\x10\x18\n\x0f\n\x07\x04\x15\x03\x01\x02\0\x05\x12\x04\x91\x01\
    \x19\x20\n\x0f\n\x07\x04\x15\x03\x01\x02\0\x01\x12\x04\x91\x01!(\n\x0f\n\
    \x07\x04\x15\x03\x01\x02\0\x03\x12\x04\x91\x01+,\n\x0e\n\x06\x04\x15\x03\
    \x01\x02\x01\x12\x04\x92\x01\x10c\n\x0f\n\x07\x04\x15\x03\x01\x02\x01\
    \x04\x12\x04\x92\x01\x10\x18\n\x0f\n\x07\x04\x15\x03\x01\x02\x01\x06\x12\
    \x04\x92\x01\x19Q\n\x0f\n\x07\x04\x15\x03\x01\x02\x01\x01\x12\x04\x92\
    \x01R^\n\x0f\n\x07\x04\x15\x03\x01\x02\x01\x03\x12\x04\x92\x01ab\n\x0c\n\
    \x04\x04\x15\x02\0\x12\x04\x95\x01\x08_\n\r\n\x05\x04\x15\x02\0\x04\x12\
    \x04\x95\x01\x08\x10\n\r\n\x05\x04\x15\x02\0\x06\x12\x04\x95\x01\x11K\n\
    \r\n\x05\x04\x15\x02\0\x01\x12\x04\x95\x01LZ\n\r\n\x05\x04\x15\x02\0\x03\
    \x12\x04\x95\x01]^\n\x0c\n\x02\x06\0\x12\x06\x98\x01\0\xc6\x01\x01\n\x0b\
    \n\x03\x06\0\x01\x12\x04\x98\x01\x08\x12\n\x0b\n\x03\x06\0\x03\x12\x04\
    \x99\x01\x08J\n\x0e\n\x06\x06\0\x03\xd0\x86\x03\x12\x04\x99\x01\x08J\n\
    \x0e\n\x04\x06\0\x02\0\x12\x06\x9b\x01\x08\x9d\x01\t\n\r\n\x05\x06\0\x02\
    \0\x01\x12\x04\x9b\x01\x0c#\n\r\n\x05\x06\0\x02\0\x02\x12\x04\x9b\x01%Q\
    \n\x0e\n\x05\x06\0\x02\0\x03\x12\x05\x9b\x01\\\x89\x01\n\r\n\x05\x06\0\
    \x02\0\x04\x12\x04\x9c\x01\x10O\n\x10\n\x08\x06\0\x02\0\x04\xd0\x86\x03\
    \x12\x04\x9c\x01\x10O\n\x0e\n\x04\x06\0\x02\x01\x12\x06\x9f\x01\x08\xa1\
    \x01\t\n\r\n\x05\x06\0\x02\x01\x01\x12\x04\x9f\x01\x0c&\n\r\n\x05\x06\0\
    \x02\x01\x02\x12\x04\x9f\x01(W\n\x0e\n\x05\x06\0\x02\x01\x03\x12\x05\x9f\
    \x01b\x92\x01\n\r\n\x05\x06\0\x02\x01\x04\x12\x04\xa0\x01\x10a\n\x10\n\
    \x08\x06\0\x02\x01\x04\xd0\x86\x03\x12\x04\xa0\x01\x10a\n\x0e\n\x04\x06\
    \0\x02\x02\x12\x06\xa3\x01\x08\xa5\x01\t\n\r\n\x05\x06\0\x02\x02\x01\x12\
    \x04\xa3\x01\x0c!\n\r\n\x05\x06\0\x02\x02\x02\x12\x04\xa3\x01#M\n\x0e\n\
    \x05\x06\0\x02\x02\x03\x12\x05\xa3\x01X\x83\x01\n\r\n\x05\x06\0\x02\x02\
    \x04\x12\x04\xa4\x01\x10e\n\x10\n\x08\x06\0\x02\x02\x04\xd0\x86\x03\x12\
    \x04\xa4\x01\x10e\n\x0e\n\x04\x06\0\x02\x03\x12\x06\xa7\x01\x08\xa9\x01\
    \t\n\r\n\x05\x06\0\x02\x03\x01\x12\x04\xa7\x01\x0c#\n\r\n\x05\x06\0\x02\
    \x03\x02\x12\x04\xa7\x01%Q\n\x0e\n\x05\x06\0\x02\x03\x03\x12\x05\xa7\x01\
    \\\x89\x01\n\r\n\x05\x06\0\x02\x03\x04\x12\x04\xa8\x01\x10P\n\x10\n\x08\
    \x06\0\x02\x03\x04\xd0\x86\x03\x12\x04\xa8\x01\x10P\n\x0e\n\x04\x06\0\
    \x02\x04\x12\x06\xab\x01\x08\xad\x01\t\n\r\n\x05\x06\0\x02\x04\x01\x12\
    \x04\xab\x01\x0c$\n\r\n\x05\x06\0\x02\x04\x02\x12\x04\xab\x01&S\n\x0e\n\
    \x05\x06\0\x02\x04\x03\x12\x05\xab\x01^\x8c\x01\n\r\n\x05\x06\0\x02\x04\
    \x04\x12\x04\xac\x01\x10m\n\x10\n\x08\x06\0\x02\x04\x04\xd0\x86\x03\x12\
    \x04\xac\x01\x10m\n\x0e\n\x04\x06\0\x02\x05\x12\x06\xaf\x01\x08\xb1\x01\
    \t\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\xaf\x01\x0c\"\n\r\n\x05\x06\0\x02\
    \x05\x02\x12\x04\xaf\x01$O\n\x0e\n\x05\x06\0\x02\x05\x03\x12\x05\xaf\x01\
    Z\x86\x01\n\r\n\x05\x06\0\x02\x05\x04\x12\x04\xb0\x01\x10j\n\x10\n\x08\
    \x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\xb0\x01\x10j\n\x0e\n\x04\x06\0\
    \x02\x06\x12\x06\xb3\x01\x08\xb5\x01\t\n\r\n\x05\x06\0\x02\x06\x01\x12\
    \x04\xb3\x01\x0c\"\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\xb3\x01$O\n\x0e\n\
    \x05\x06\0\x02\x06\x03\x12\x05\xb3\x01Z\x86\x01\n\r\n\x05\x06\0\x02\x06\
    \x04\x12\x04\xb4\x01\x10h\n\x10\n\x08\x06\0\x02\x06\x04\xd0\x86\x03\x12\
    \x04\xb4\x01\x10h\n\x0e\n\x04\x06\0\x02\x07\x12\x06\xb7\x01\x08\xb9\x01\
    \t\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\xb7\x01\x0c%\n\r\n\x05\x06\0\x02\
    \x07\x02\x12\x04\xb7\x01'U\n\x0e\n\x05\x06\0\x02\x07\x03\x12\x05\xb7\x01\
    `\x8f\x01\n\r\n\x05\x06\0\x02\x07\x04\x12\x04\xb8\x01\x10k\n\x10\n\x08\
    \x06\0\x02\x07\x04\xd0\x86\x03\x12\x04\xb8\x01\x10k\n\x0e\n\x04\x06\0\
    \x02\x08\x12\x06\xbb\x01\x08\xbd\x01\t\n\r\n\x05\x06\0\x02\x08\x01\x12\
    \x04\xbb\x01\x0c#\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\xbb\x01%Q\n\x0e\n\
    \x05\x06\0\x02\x08\x03\x12\x05\xbb\x01\\\x89\x01\n\r\n\x05\x06\0\x02\x08\
    \x04\x12\x04\xbc\x01\x10n\n\x10\n\x08\x06\0\x02\x08\x04\xd0\x86\x03\x12\
    \x04\xbc\x01\x10n\n\x0e\n\x04\x06\0\x02\t\x12\x06\xbf\x01\x08\xc1\x01\t\
    \n\r\n\x05\x06\0\x02\t\x01\x12\x04\xbf\x01\x0c%\n\r\n\x05\x06\0\x02\t\
    \x02\x12\x04\xbf\x01'U\n\x0e\n\x05\x06\0\x02\t\x03\x12\x05\xbf\x01`\x8f\
    \x01\n\r\n\x05\x06\0\x02\t\x04\x12\x04\xc0\x01\x10^\n\x10\n\x08\x06\0\
    \x02\t\x04\xd0\x86\x03\x12\x04\xc0\x01\x10^\n\x0e\n\x04\x06\0\x02\n\x12\
    \x06\xc3\x01\x08\xc5\x01\t\n\r\n\x05\x06\0\x02\n\x01\x12\x04\xc3\x01\x0c\
    \"\n\r\n\x05\x06\0\x02\n\x02\x12\x04\xc3\x01$O\n\x0e\n\x05\x06\0\x02\n\
    \x03\x12\x05\xc3\x01Z\x86\x01\n\r\n\x05\x06\0\x02\n\x04\x12\x04\xc4\x01\
    \x10R\n\x10\n\x08\x06\0\x02\n\x04\xd0\x86\x03\x12\x04\xc4\x01\x10R\
";

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()
    })
}