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_parental.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 ParentalApp {
    // message fields
    appid: ::std::option::Option<u32>,
    is_allowed: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl ParentalApp {
    pub fn new() -> ParentalApp {
        ::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 bool is_allowed = 2;


    pub fn get_is_allowed(&self) -> bool {
        self.is_allowed.unwrap_or(false)
    }
    pub fn clear_is_allowed(&mut self) {
        self.is_allowed = ::std::option::Option::None;
    }

    pub fn has_is_allowed(&self) -> bool {
        self.is_allowed.is_some()
    }

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

impl ::protobuf::Message for ParentalApp {
    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_bool()?;
                    self.is_allowed = ::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.is_allowed {
            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(v) = self.is_allowed {
            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() -> ParentalApp {
        ParentalApp::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: &ParentalApp| { &m.appid },
                |m: &mut ParentalApp| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_allowed",
                |m: &ParentalApp| { &m.is_allowed },
                |m: &mut ParentalApp| { &mut m.is_allowed },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ParentalApp>(
                "ParentalApp",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ParentalSettings {
    // message fields
    steamid: ::std::option::Option<u64>,
    applist_base_id: ::std::option::Option<u32>,
    applist_base_description: ::protobuf::SingularField<::std::string::String>,
    pub applist_base: ::protobuf::RepeatedField<ParentalApp>,
    pub applist_custom: ::protobuf::RepeatedField<ParentalApp>,
    passwordhashtype: ::std::option::Option<u32>,
    salt: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    passwordhash: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    is_enabled: ::std::option::Option<bool>,
    enabled_features: ::std::option::Option<u32>,
    recovery_email: ::protobuf::SingularField<::std::string::String>,
    is_site_license_lock: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

impl ParentalSettings {
    pub fn new() -> ParentalSettings {
        ::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 applist_base_id = 2;


    pub fn get_applist_base_id(&self) -> u32 {
        self.applist_base_id.unwrap_or(0)
    }
    pub fn clear_applist_base_id(&mut self) {
        self.applist_base_id = ::std::option::Option::None;
    }

    pub fn has_applist_base_id(&self) -> bool {
        self.applist_base_id.is_some()
    }

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

    // optional string applist_base_description = 3;


    pub fn get_applist_base_description(&self) -> &str {
        match self.applist_base_description.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_applist_base_description(&mut self) {
        self.applist_base_description.clear();
    }

    pub fn has_applist_base_description(&self) -> bool {
        self.applist_base_description.is_some()
    }

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

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

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

    // repeated .ParentalApp applist_base = 4;


    pub fn get_applist_base(&self) -> &[ParentalApp] {
        &self.applist_base
    }
    pub fn clear_applist_base(&mut self) {
        self.applist_base.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_applist_base(&mut self) -> &mut ::protobuf::RepeatedField<ParentalApp> {
        &mut self.applist_base
    }

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

    // repeated .ParentalApp applist_custom = 5;


    pub fn get_applist_custom(&self) -> &[ParentalApp] {
        &self.applist_custom
    }
    pub fn clear_applist_custom(&mut self) {
        self.applist_custom.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_applist_custom(&mut self) -> &mut ::protobuf::RepeatedField<ParentalApp> {
        &mut self.applist_custom
    }

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

    // optional uint32 passwordhashtype = 6;


    pub fn get_passwordhashtype(&self) -> u32 {
        self.passwordhashtype.unwrap_or(0)
    }
    pub fn clear_passwordhashtype(&mut self) {
        self.passwordhashtype = ::std::option::Option::None;
    }

    pub fn has_passwordhashtype(&self) -> bool {
        self.passwordhashtype.is_some()
    }

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

    // optional bytes salt = 7;


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

    pub fn has_salt(&self) -> bool {
        self.salt.is_some()
    }

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

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

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

    // optional bytes passwordhash = 8;


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

    pub fn has_passwordhash(&self) -> bool {
        self.passwordhash.is_some()
    }

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

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

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

    // optional bool is_enabled = 9;


    pub fn get_is_enabled(&self) -> bool {
        self.is_enabled.unwrap_or(false)
    }
    pub fn clear_is_enabled(&mut self) {
        self.is_enabled = ::std::option::Option::None;
    }

    pub fn has_is_enabled(&self) -> bool {
        self.is_enabled.is_some()
    }

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

    // optional uint32 enabled_features = 10;


    pub fn get_enabled_features(&self) -> u32 {
        self.enabled_features.unwrap_or(0)
    }
    pub fn clear_enabled_features(&mut self) {
        self.enabled_features = ::std::option::Option::None;
    }

    pub fn has_enabled_features(&self) -> bool {
        self.enabled_features.is_some()
    }

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

    // optional string recovery_email = 11;


    pub fn get_recovery_email(&self) -> &str {
        match self.recovery_email.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_recovery_email(&mut self) {
        self.recovery_email.clear();
    }

    pub fn has_recovery_email(&self) -> bool {
        self.recovery_email.is_some()
    }

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

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

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

    // optional bool is_site_license_lock = 12;


    pub fn get_is_site_license_lock(&self) -> bool {
        self.is_site_license_lock.unwrap_or(false)
    }
    pub fn clear_is_site_license_lock(&mut self) {
        self.is_site_license_lock = ::std::option::Option::None;
    }

    pub fn has_is_site_license_lock(&self) -> bool {
        self.is_site_license_lock.is_some()
    }

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

impl ::protobuf::Message for ParentalSettings {
    fn is_initialized(&self) -> bool {
        for v in &self.applist_base {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.applist_custom {
            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 => {
                    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.applist_base_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.applist_base_description)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.applist_base)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.applist_custom)?;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.passwordhashtype = ::std::option::Option::Some(tmp);
                },
                7 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.salt)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.passwordhash)?;
                },
                9 => {
                    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_enabled = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.enabled_features = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.recovery_email)?;
                },
                12 => {
                    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_site_license_lock = ::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.applist_base_id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.applist_base_description.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        for value in &self.applist_base {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.applist_custom {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.passwordhashtype {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.salt.as_ref() {
            my_size += ::protobuf::rt::bytes_size(7, &v);
        }
        if let Some(ref v) = self.passwordhash.as_ref() {
            my_size += ::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(v) = self.is_enabled {
            my_size += 2;
        }
        if let Some(v) = self.enabled_features {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.recovery_email.as_ref() {
            my_size += ::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.is_site_license_lock {
            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.applist_base_id {
            os.write_uint32(2, v)?;
        }
        if let Some(ref v) = self.applist_base_description.as_ref() {
            os.write_string(3, &v)?;
        }
        for v in &self.applist_base {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.applist_custom {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.passwordhashtype {
            os.write_uint32(6, v)?;
        }
        if let Some(ref v) = self.salt.as_ref() {
            os.write_bytes(7, &v)?;
        }
        if let Some(ref v) = self.passwordhash.as_ref() {
            os.write_bytes(8, &v)?;
        }
        if let Some(v) = self.is_enabled {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.enabled_features {
            os.write_uint32(10, v)?;
        }
        if let Some(ref v) = self.recovery_email.as_ref() {
            os.write_string(11, &v)?;
        }
        if let Some(v) = self.is_site_license_lock {
            os.write_bool(12, 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() -> ParentalSettings {
        ParentalSettings::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: &ParentalSettings| { &m.steamid },
                |m: &mut ParentalSettings| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "applist_base_id",
                |m: &ParentalSettings| { &m.applist_base_id },
                |m: &mut ParentalSettings| { &mut m.applist_base_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "applist_base_description",
                |m: &ParentalSettings| { &m.applist_base_description },
                |m: &mut ParentalSettings| { &mut m.applist_base_description },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalApp>>(
                "applist_base",
                |m: &ParentalSettings| { &m.applist_base },
                |m: &mut ParentalSettings| { &mut m.applist_base },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalApp>>(
                "applist_custom",
                |m: &ParentalSettings| { &m.applist_custom },
                |m: &mut ParentalSettings| { &mut m.applist_custom },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "passwordhashtype",
                |m: &ParentalSettings| { &m.passwordhashtype },
                |m: &mut ParentalSettings| { &mut m.passwordhashtype },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "salt",
                |m: &ParentalSettings| { &m.salt },
                |m: &mut ParentalSettings| { &mut m.salt },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "passwordhash",
                |m: &ParentalSettings| { &m.passwordhash },
                |m: &mut ParentalSettings| { &mut m.passwordhash },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_enabled",
                |m: &ParentalSettings| { &m.is_enabled },
                |m: &mut ParentalSettings| { &mut m.is_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "enabled_features",
                |m: &ParentalSettings| { &m.enabled_features },
                |m: &mut ParentalSettings| { &mut m.enabled_features },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "recovery_email",
                |m: &ParentalSettings| { &m.recovery_email },
                |m: &mut ParentalSettings| { &mut m.recovery_email },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_site_license_lock",
                |m: &ParentalSettings| { &m.is_site_license_lock },
                |m: &mut ParentalSettings| { &mut m.is_site_license_lock },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ParentalSettings>(
                "ParentalSettings",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ParentalSettings {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.applist_base_id = ::std::option::Option::None;
        self.applist_base_description.clear();
        self.applist_base.clear();
        self.applist_custom.clear();
        self.passwordhashtype = ::std::option::Option::None;
        self.salt.clear();
        self.passwordhash.clear();
        self.is_enabled = ::std::option::Option::None;
        self.enabled_features = ::std::option::Option::None;
        self.recovery_email.clear();
        self.is_site_license_lock = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_EnableParentalSettings_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    pub settings: ::protobuf::SingularPtrField<ParentalSettings>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    enablecode: ::std::option::Option<u32>,
    steamid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

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

    // optional .ParentalSettings settings = 2;


    pub fn get_settings(&self) -> &ParentalSettings {
        self.settings.as_ref().unwrap_or_else(|| <ParentalSettings as ::protobuf::Message>::default_instance())
    }
    pub fn clear_settings(&mut self) {
        self.settings.clear();
    }

    pub fn has_settings(&self) -> bool {
        self.settings.is_some()
    }

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

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

    // Take field
    pub fn take_settings(&mut self) -> ParentalSettings {
        self.settings.take().unwrap_or_else(|| ParentalSettings::new())
    }

    // optional string sessionid = 3;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

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

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

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

    // optional uint32 enablecode = 4;


    pub fn get_enablecode(&self) -> u32 {
        self.enablecode.unwrap_or(0)
    }
    pub fn clear_enablecode(&mut self) {
        self.enablecode = ::std::option::Option::None;
    }

    pub fn has_enablecode(&self) -> bool {
        self.enablecode.is_some()
    }

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

    // optional fixed64 steamid = 10;


    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 CParental_EnableParentalSettings_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.settings {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.settings)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                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.enablecode = ::std::option::Option::Some(tmp);
                },
                10 => {
                    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(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.enablecode {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.settings.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(v) = self.enablecode {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CParental_EnableParentalSettings_Request {
        CParental_EnableParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_EnableParentalSettings_Request| { &m.password },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalSettings>>(
                "settings",
                |m: &CParental_EnableParentalSettings_Request| { &m.settings },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_EnableParentalSettings_Request| { &m.sessionid },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.sessionid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "enablecode",
                |m: &CParental_EnableParentalSettings_Request| { &m.enablecode },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.enablecode },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_EnableParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_EnableParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_EnableParentalSettings_Request>(
                "CParental_EnableParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_EnableParentalSettings_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.settings.clear();
        self.sessionid.clear();
        self.enablecode = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

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

    // optional fixed64 steamid = 10;


    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 CParental_DisableParentalSettings_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                10 => {
                    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(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CParental_DisableParentalSettings_Request {
        CParental_DisableParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_DisableParentalSettings_Request| { &m.password },
                |m: &mut CParental_DisableParentalSettings_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_DisableParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_DisableParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_DisableParentalSettings_Request>(
                "CParental_DisableParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_GetParentalSettings_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 CParental_GetParentalSettings_Request {
    fn default() -> &'a CParental_GetParentalSettings_Request {
        <CParental_GetParentalSettings_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional fixed64 steamid = 10;


    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 CParental_GetParentalSettings_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 {
                10 => {
                    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(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CParental_GetParentalSettings_Request {
        CParental_GetParentalSettings_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: &CParental_GetParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_GetParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetParentalSettings_Request>(
                "CParental_GetParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_GetParentalSettings_Response {
    // message fields
    pub settings: ::protobuf::SingularPtrField<ParentalSettings>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .ParentalSettings settings = 1;


    pub fn get_settings(&self) -> &ParentalSettings {
        self.settings.as_ref().unwrap_or_else(|| <ParentalSettings as ::protobuf::Message>::default_instance())
    }
    pub fn clear_settings(&mut self) {
        self.settings.clear();
    }

    pub fn has_settings(&self) -> bool {
        self.settings.is_some()
    }

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

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

    // Take field
    pub fn take_settings(&mut self) -> ParentalSettings {
        self.settings.take().unwrap_or_else(|| ParentalSettings::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.settings)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.settings.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        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() -> CParental_GetParentalSettings_Response {
        CParental_GetParentalSettings_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_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalSettings>>(
                "settings",
                |m: &CParental_GetParentalSettings_Response| { &m.settings },
                |m: &mut CParental_GetParentalSettings_Response| { &mut m.settings },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetParentalSettings_Response>(
                "CParental_GetParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional uint32 priority = 1;


    pub fn get_priority(&self) -> u32 {
        self.priority.unwrap_or(0)
    }
    pub fn clear_priority(&mut self) {
        self.priority = ::std::option::Option::None;
    }

    pub fn has_priority(&self) -> bool {
        self.priority.is_some()
    }

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

impl ::protobuf::Message for CParental_GetSignedParentalSettings_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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.priority = ::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.priority {
            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.priority {
            os.write_uint32(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() -> CParental_GetSignedParentalSettings_Request {
        CParental_GetSignedParentalSettings_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::ProtobufTypeUint32>(
                "priority",
                |m: &CParental_GetSignedParentalSettings_Request| { &m.priority },
                |m: &mut CParental_GetSignedParentalSettings_Request| { &mut m.priority },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetSignedParentalSettings_Request>(
                "CParental_GetSignedParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_GetSignedParentalSettings_Response {
    // message fields
    serialized_settings: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes serialized_settings = 1;


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

    pub fn has_serialized_settings(&self) -> bool {
        self.serialized_settings.is_some()
    }

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

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

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

    // optional bytes signature = 2;


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

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

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

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

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

impl ::protobuf::Message for CParental_GetSignedParentalSettings_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 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.serialized_settings)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.serialized_settings.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.serialized_settings.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CParental_GetSignedParentalSettings_Response {
        CParental_GetSignedParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "serialized_settings",
                |m: &CParental_GetSignedParentalSettings_Response| { &m.serialized_settings },
                |m: &mut CParental_GetSignedParentalSettings_Response| { &mut m.serialized_settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CParental_GetSignedParentalSettings_Response| { &m.signature },
                |m: &mut CParental_GetSignedParentalSettings_Response| { &mut m.signature },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_GetSignedParentalSettings_Response>(
                "CParental_GetSignedParentalSettings_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_SetParentalSettings_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    pub settings: ::protobuf::SingularPtrField<ParentalSettings>,
    new_password: ::protobuf::SingularField<::std::string::String>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    steamid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

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

    // optional .ParentalSettings settings = 2;


    pub fn get_settings(&self) -> &ParentalSettings {
        self.settings.as_ref().unwrap_or_else(|| <ParentalSettings as ::protobuf::Message>::default_instance())
    }
    pub fn clear_settings(&mut self) {
        self.settings.clear();
    }

    pub fn has_settings(&self) -> bool {
        self.settings.is_some()
    }

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

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

    // Take field
    pub fn take_settings(&mut self) -> ParentalSettings {
        self.settings.take().unwrap_or_else(|| ParentalSettings::new())
    }

    // optional string new_password = 3;


    pub fn get_new_password(&self) -> &str {
        match self.new_password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_new_password(&mut self) {
        self.new_password.clear();
    }

    pub fn has_new_password(&self) -> bool {
        self.new_password.is_some()
    }

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

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

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

    // optional string sessionid = 4;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

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

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

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

    // optional fixed64 steamid = 10;


    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 CParental_SetParentalSettings_Request {
    fn is_initialized(&self) -> bool {
        for v in &self.settings {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.settings)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.new_password)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                10 => {
                    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(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.settings.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.new_password.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.settings.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.new_password.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CParental_SetParentalSettings_Request {
        CParental_SetParentalSettings_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_SetParentalSettings_Request| { &m.password },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParentalSettings>>(
                "settings",
                |m: &CParental_SetParentalSettings_Request| { &m.settings },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "new_password",
                |m: &CParental_SetParentalSettings_Request| { &m.new_password },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.new_password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_SetParentalSettings_Request| { &m.sessionid },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.sessionid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_SetParentalSettings_Request| { &m.steamid },
                |m: &mut CParental_SetParentalSettings_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_SetParentalSettings_Request>(
                "CParental_SetParentalSettings_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_SetParentalSettings_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.settings.clear();
        self.new_password.clear();
        self.sessionid.clear();
        self.steamid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_ValidateToken_Request {
    // message fields
    unlock_token: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string unlock_token = 1;


    pub fn get_unlock_token(&self) -> &str {
        match self.unlock_token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_unlock_token(&mut self) {
        self.unlock_token.clear();
    }

    pub fn has_unlock_token(&self) -> bool {
        self.unlock_token.is_some()
    }

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

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

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

impl ::protobuf::Message for CParental_ValidateToken_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.unlock_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.unlock_token.as_ref() {
            os.write_string(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() -> CParental_ValidateToken_Request {
        CParental_ValidateToken_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "unlock_token",
                |m: &CParental_ValidateToken_Request| { &m.unlock_token },
                |m: &mut CParental_ValidateToken_Request| { &mut m.unlock_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ValidateToken_Request>(
                "CParental_ValidateToken_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_ValidatePassword_Request {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    session: ::protobuf::SingularField<::std::string::String>,
    send_unlock_on_success: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

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

    // optional string session = 2;


    pub fn get_session(&self) -> &str {
        match self.session.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    pub fn has_session(&self) -> bool {
        self.session.is_some()
    }

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

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

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

    // optional bool send_unlock_on_success = 3;


    pub fn get_send_unlock_on_success(&self) -> bool {
        self.send_unlock_on_success.unwrap_or(false)
    }
    pub fn clear_send_unlock_on_success(&mut self) {
        self.send_unlock_on_success = ::std::option::Option::None;
    }

    pub fn has_send_unlock_on_success(&self) -> bool {
        self.send_unlock_on_success.is_some()
    }

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

impl ::protobuf::Message for CParental_ValidatePassword_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.session)?;
                },
                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.send_unlock_on_success = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.session.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.send_unlock_on_success {
            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(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.session.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.send_unlock_on_success {
            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() -> CParental_ValidatePassword_Request {
        CParental_ValidatePassword_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_ValidatePassword_Request| { &m.password },
                |m: &mut CParental_ValidatePassword_Request| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &CParental_ValidatePassword_Request| { &m.session },
                |m: &mut CParental_ValidatePassword_Request| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "send_unlock_on_success",
                |m: &CParental_ValidatePassword_Request| { &m.send_unlock_on_success },
                |m: &mut CParental_ValidatePassword_Request| { &mut m.send_unlock_on_success },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ValidatePassword_Request>(
                "CParental_ValidatePassword_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_ValidatePassword_Request {
    fn clear(&mut self) {
        self.password.clear();
        self.session.clear();
        self.send_unlock_on_success = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_ValidatePassword_Response {
    // message fields
    token: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string token = 1;


    pub fn get_token(&self) -> &str {
        match self.token.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_token(&mut self) {
        self.token.clear();
    }

    pub fn has_token(&self) -> bool {
        self.token.is_some()
    }

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

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

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

impl ::protobuf::Message for CParental_ValidatePassword_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.token.as_ref() {
            os.write_string(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() -> CParental_ValidatePassword_Response {
        CParental_ValidatePassword_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "token",
                |m: &CParental_ValidatePassword_Response| { &m.token },
                |m: &mut CParental_ValidatePassword_Response| { &mut m.token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ValidatePassword_Response>(
                "CParental_ValidatePassword_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_LockClient_Request {
    // message fields
    session: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string session = 1;


    pub fn get_session(&self) -> &str {
        match self.session.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    pub fn has_session(&self) -> bool {
        self.session.is_some()
    }

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

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

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

impl ::protobuf::Message for CParental_LockClient_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 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.session)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.session.as_ref() {
            os.write_string(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() -> CParental_LockClient_Request {
        CParental_LockClient_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &CParental_LockClient_Request| { &m.session },
                |m: &mut CParental_LockClient_Request| { &mut m.session },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_LockClient_Request>(
                "CParental_LockClient_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint32 recovery_code = 1;


    pub fn get_recovery_code(&self) -> u32 {
        self.recovery_code.unwrap_or(0)
    }
    pub fn clear_recovery_code(&mut self) {
        self.recovery_code = ::std::option::Option::None;
    }

    pub fn has_recovery_code(&self) -> bool {
        self.recovery_code.is_some()
    }

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

    // optional fixed64 steamid = 10;


    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 CParental_DisableWithRecoveryCode_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::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.recovery_code = ::std::option::Option::Some(tmp);
                },
                10 => {
                    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.recovery_code {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        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.recovery_code {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CParental_DisableWithRecoveryCode_Request {
        CParental_DisableWithRecoveryCode_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::ProtobufTypeUint32>(
                "recovery_code",
                |m: &CParental_DisableWithRecoveryCode_Request| { &m.recovery_code },
                |m: &mut CParental_DisableWithRecoveryCode_Request| { &mut m.recovery_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CParental_DisableWithRecoveryCode_Request| { &m.steamid },
                |m: &mut CParental_DisableWithRecoveryCode_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_DisableWithRecoveryCode_Request>(
                "CParental_DisableWithRecoveryCode_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_ParentalSettingsChange_Notification {
    // message fields
    serialized_settings: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    signature: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    password: ::protobuf::SingularField<::std::string::String>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes serialized_settings = 1;


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

    pub fn has_serialized_settings(&self) -> bool {
        self.serialized_settings.is_some()
    }

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

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

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

    // optional bytes signature = 2;


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

    pub fn has_signature(&self) -> bool {
        self.signature.is_some()
    }

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

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

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

    // optional string password = 3;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

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

    // optional string sessionid = 4;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.serialized_settings)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.serialized_settings.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.signature.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.serialized_settings.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.signature.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.password.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(4, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "serialized_settings",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.serialized_settings },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.serialized_settings },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "signature",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.signature },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.signature },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "password",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.password },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.password },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sessionid",
                |m: &CParental_ParentalSettingsChange_Notification| { &m.sessionid },
                |m: &mut CParental_ParentalSettingsChange_Notification| { &mut m.sessionid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CParental_ParentalSettingsChange_Notification>(
                "CParental_ParentalSettingsChange_Notification",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CParental_ParentalSettingsChange_Notification {
    fn clear(&mut self) {
        self.serialized_settings.clear();
        self.signature.clear();
        self.password.clear();
        self.sessionid.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_ParentalUnlock_Notification {
    // message fields
    password: ::protobuf::SingularField<::std::string::String>,
    sessionid: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string password = 1;


    pub fn get_password(&self) -> &str {
        match self.password.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

    pub fn has_password(&self) -> bool {
        self.password.is_some()
    }

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

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

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

    // optional string sessionid = 2;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.password.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.password.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(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() -> CParental_ParentalUnlock_Notification {
        CParental_ParentalUnlock_Notification::new()
    }

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CParental_ParentalLock_Notification {
    // message fields
    sessionid: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string sessionid = 1;


    pub fn get_sessionid(&self) -> &str {
        match self.sessionid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sessionid(&mut self) {
        self.sessionid.clear();
    }

    pub fn has_sessionid(&self) -> bool {
        self.sessionid.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sessionid)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.sessionid.as_ref() {
            os.write_string(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() -> CParental_ParentalLock_Notification {
        CParental_ParentalLock_Notification::new()
    }

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

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n(steammessages_parental.steamclient.proto\x1a,steammessages_unified_ba\
    se.steamclient.proto\"B\n\x0bParentalApp\x12\x14\n\x05appid\x18\x01\x20\
    \x01(\rR\x05appid\x12\x1d\n\nis_allowed\x18\x02\x20\x01(\x08R\tisAllowed\
    \"\xfa\x03\n\x10ParentalSettings\x12\x18\n\x07steamid\x18\x01\x20\x01(\
    \x06R\x07steamid\x12&\n\x0fapplist_base_id\x18\x02\x20\x01(\rR\rapplistB\
    aseId\x128\n\x18applist_base_description\x18\x03\x20\x01(\tR\x16applistB\
    aseDescription\x12/\n\x0capplist_base\x18\x04\x20\x03(\x0b2\x0c.Parental\
    AppR\x0bapplistBase\x123\n\x0eapplist_custom\x18\x05\x20\x03(\x0b2\x0c.P\
    arentalAppR\rapplistCustom\x12*\n\x10passwordhashtype\x18\x06\x20\x01(\r\
    R\x10passwordhashtype\x12\x12\n\x04salt\x18\x07\x20\x01(\x0cR\x04salt\
    \x12\"\n\x0cpasswordhash\x18\x08\x20\x01(\x0cR\x0cpasswordhash\x12\x1d\n\
    \nis_enabled\x18\t\x20\x01(\x08R\tisEnabled\x12)\n\x10enabled_features\
    \x18\n\x20\x01(\rR\x0fenabledFeatures\x12%\n\x0erecovery_email\x18\x0b\
    \x20\x01(\tR\rrecoveryEmail\x12/\n\x14is_site_license_lock\x18\x0c\x20\
    \x01(\x08R\x11isSiteLicenseLock\"\xcd\x01\n(CParental_EnableParentalSett\
    ings_Request\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08password\x12-\
    \n\x08settings\x18\x02\x20\x01(\x0b2\x11.ParentalSettingsR\x08settings\
    \x12\x1c\n\tsessionid\x18\x03\x20\x01(\tR\tsessionid\x12\x1e\n\nenableco\
    de\x18\x04\x20\x01(\rR\nenablecode\x12\x18\n\x07steamid\x18\n\x20\x01(\
    \x06R\x07steamid\"+\n)CParental_EnableParentalSettings_Response\"a\n)CPa\
    rental_DisableParentalSettings_Request\x12\x1a\n\x08password\x18\x01\x20\
    \x01(\tR\x08password\x12\x18\n\x07steamid\x18\n\x20\x01(\x06R\x07steamid\
    \",\n*CParental_DisableParentalSettings_Response\"A\n%CParental_GetParen\
    talSettings_Request\x12\x18\n\x07steamid\x18\n\x20\x01(\x06R\x07steamid\
    \"W\n&CParental_GetParentalSettings_Response\x12-\n\x08settings\x18\x01\
    \x20\x01(\x0b2\x11.ParentalSettingsR\x08settings\"I\n+CParental_GetSigne\
    dParentalSettings_Request\x12\x1a\n\x08priority\x18\x01\x20\x01(\rR\x08p\
    riority\"}\n,CParental_GetSignedParentalSettings_Response\x12/\n\x13seri\
    alized_settings\x18\x01\x20\x01(\x0cR\x12serializedSettings\x12\x1c\n\ts\
    ignature\x18\x02\x20\x01(\x0cR\tsignature\"\xcd\x01\n%CParental_SetParen\
    talSettings_Request\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08passwor\
    d\x12-\n\x08settings\x18\x02\x20\x01(\x0b2\x11.ParentalSettingsR\x08sett\
    ings\x12!\n\x0cnew_password\x18\x03\x20\x01(\tR\x0bnewPassword\x12\x1c\n\
    \tsessionid\x18\x04\x20\x01(\tR\tsessionid\x12\x18\n\x07steamid\x18\n\
    \x20\x01(\x06R\x07steamid\"(\n&CParental_SetParentalSettings_Response\"D\
    \n\x1fCParental_ValidateToken_Request\x12!\n\x0cunlock_token\x18\x01\x20\
    \x01(\tR\x0bunlockToken\"\"\n\x20CParental_ValidateToken_Response\"\x8f\
    \x01\n\"CParental_ValidatePassword_Request\x12\x1a\n\x08password\x18\x01\
    \x20\x01(\tR\x08password\x12\x18\n\x07session\x18\x02\x20\x01(\tR\x07ses\
    sion\x123\n\x16send_unlock_on_success\x18\x03\x20\x01(\x08R\x13sendUnloc\
    kOnSuccess\";\n#CParental_ValidatePassword_Response\x12\x14\n\x05token\
    \x18\x01\x20\x01(\tR\x05token\"8\n\x1cCParental_LockClient_Request\x12\
    \x18\n\x07session\x18\x01\x20\x01(\tR\x07session\"\x1f\n\x1dCParental_Lo\
    ckClient_Response\"'\n%CParental_RequestRecoveryCode_Request\"(\n&CParen\
    tal_RequestRecoveryCode_Response\"j\n)CParental_DisableWithRecoveryCode_\
    Request\x12#\n\rrecovery_code\x18\x01\x20\x01(\rR\x0crecoveryCode\x12\
    \x18\n\x07steamid\x18\n\x20\x01(\x06R\x07steamid\",\n*CParental_DisableW\
    ithRecoveryCode_Response\"\xb8\x01\n-CParental_ParentalSettingsChange_No\
    tification\x12/\n\x13serialized_settings\x18\x01\x20\x01(\x0cR\x12serial\
    izedSettings\x12\x1c\n\tsignature\x18\x02\x20\x01(\x0cR\tsignature\x12\
    \x1a\n\x08password\x18\x03\x20\x01(\tR\x08password\x12\x1c\n\tsessionid\
    \x18\x04\x20\x01(\tR\tsessionid\"a\n%CParental_ParentalUnlock_Notificati\
    on\x12\x1a\n\x08password\x18\x01\x20\x01(\tR\x08password\x12\x1c\n\tsess\
    ionid\x18\x02\x20\x01(\tR\tsessionid\"C\n#CParental_ParentalLock_Notific\
    ation\x12\x1c\n\tsessionid\x18\x01\x20\x01(\tR\tsessionid2\xd2\x0e\n\x08\
    Parental\x12\xd0\x01\n\x16EnableParentalSettings\x12).CParental_EnablePa\
    rentalSettings_Request\x1a*.CParental_EnableParentalSettings_Response\"_\
    \x82\xb5\x18[Enable\x20parental\x20settings\x20for\x20the\x20logged\x20i\
    n\x20account,\x20optionally\x20setting\x20the\x20current\x20settings\x12\
    \xab\x01\n\x17DisableParentalSettings\x12*.CParental_DisableParentalSett\
    ings_Request\x1a+.CParental_DisableParentalSettings_Response\"7\x82\xb5\
    \x183Disable\x20parental\x20settings\x20for\x20the\x20logged\x20in\x20ac\
    count\x12\xa7\x01\n\x13GetParentalSettings\x12&.CParental_GetParentalSet\
    tings_Request\x1a'.CParental_GetParentalSettings_Response\"?\x82\xb5\x18\
    ;Get\x20the\x20current\x20parental\x20settings\x20for\x20the\x20logged\
    \x20in\x20account\x12\xe8\x01\n\x19GetSignedParentalSettings\x12,.CParen\
    tal_GetSignedParentalSettings_Request\x1a-.CParental_GetSignedParentalSe\
    ttings_Response\"n\x82\xb5\x18jGet\x20the\x20current\x20parental\x20sett\
    ings\x20for\x20the\x20logged\x20in\x20account\x20in\x20a\x20form\x20that\
    \x20can\x20by\x20verified\x20by\x20the\x20receiver\x12\xa7\x01\n\x13SetP\
    arentalSettings\x12&.CParental_SetParentalSettings_Request\x1a'.CParenta\
    l_SetParentalSettings_Response\"?\x82\xb5\x18;Set\x20the\x20current\x20p\
    arental\x20settings\x20for\x20the\x20logged\x20in\x20account\x12\xa7\x01\
    \n\rValidateToken\x12\x20.CParental_ValidateToken_Request\x1a!.CParental\
    _ValidateToken_Response\"Q\x82\xb5\x18MCheck\x20if\x20the\x20given\x20pa\
    rental\x20unlock\x20token\x20is\x20correct\x20for\x20the\x20logged\x20in\
    \x20account\x12\xb7\x01\n\x10ValidatePassword\x12#.CParental_ValidatePas\
    sword_Request\x1a$.CParental_ValidatePassword_Response\"X\x82\xb5\x18TVa\
    lidate\x20the\x20plaintext\x20password\x20for\x20the\x20logged\x20in\x20\
    account\x20and\x20return\x20an\x20unlock\x20token\x12\x8f\x01\n\nLockCli\
    ent\x12\x1d.CParental_LockClient_Request\x1a\x1e.CParental_LockClient_Re\
    sponse\"B\x82\xb5\x18>Notify\x20connected\x20clients\x20that\x20a\x20loc\
    k\x20has\x20occurred\x20in\x20a\x20browser\x12\xc3\x01\n\x13RequestRecov\
    eryCode\x12&.CParental_RequestRecoveryCode_Request\x1a'.CParental_Reques\
    tRecoveryCode_Response\"[\x82\xb5\x18WRequest\x20a\x20recovery\x20code\
    \x20be\x20sent\x20to\x20the\x20recovery\x20email\x20address\x20for\x20th\
    e\x20specified\x20account\x12\xaa\x01\n\x17DisableWithRecoveryCode\x12*.\
    CParental_DisableWithRecoveryCode_Request\x1a+.CParental_DisableWithReco\
    veryCode_Response\"6\x82\xb5\x182Attempt\x20a\x20recovery\x20unlock\x20o\
    n\x20the\x20specified\x20account\x1a\x1d\x82\xb5\x18\x19Parental\x20sett\
    ings\x20service2\x86\x04\n\x0eParentalClient\x12\x9c\x01\n\x14NotifySett\
    ingsChange\x12..CParental_ParentalSettingsChange_Notification\x1a\x0b.No\
    Response\"G\x82\xb5\x18CNotification\x20from\x20server\x20to\x20client\
    \x20of\x20a\x20change\x20in\x20parental\x20settings\x12\x94\x01\n\x0cNot\
    ifyUnlock\x12&.CParental_ParentalUnlock_Notification\x1a\x0b.NoResponse\
    \"O\x82\xb5\x18KNotification\x20from\x20server\x20to\x20client\x20that\
    \x20an\x20unlock\x20has\x20occurred\x20in\x20a\x20browser\x12\x8d\x01\n\
    \nNotifyLock\x12$.CParental_ParentalLock_Notification\x1a\x0b.NoResponse\
    \"L\x82\xb5\x18HNotification\x20from\x20server\x20to\x20client\x20that\
    \x20a\x20lock\x20has\x20occurred\x20in\x20a\x20browser\x1a.\x82\xb5\x18&\
    Parental\x20settings\x20client\x20notifications\xc0\xb5\x18\x02B\x03\x80\
    \x01\x01J\xc2(\n\x07\x12\x05\0\0\xb8\x01\x01\n\t\n\x02\x03\0\x12\x03\0\0\
    6\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\x08\
    \x13\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\x17\
    \n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x05\x18\x1d\n\x0c\n\x05\x04\0\x02\0\
    \x03\x12\x03\x05\x20!\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\x20\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\x08\x18\n\x0b\n\x04\x04\x01\x02\
    \0\x12\x03\n\x08%\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\n\x08\x10\n\x0c\
    \n\x05\x04\x01\x02\0\x05\x12\x03\n\x11\x18\n\x0c\n\x05\x04\x01\x02\0\x01\
    \x12\x03\n\x19\x20\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\n#$\n\x0b\n\x04\
    \x04\x01\x02\x01\x12\x03\x0b\x08,\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\
    \x03\x0b\x08\x10\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x0b\x11\x17\n\
    \x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x0b\x18'\n\x0c\n\x05\x04\x01\x02\
    \x01\x03\x12\x03\x0b*+\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x0c\x085\n\
    \x0c\n\x05\x04\x01\x02\x02\x04\x12\x03\x0c\x08\x10\n\x0c\n\x05\x04\x01\
    \x02\x02\x05\x12\x03\x0c\x11\x17\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\
    \x0c\x180\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x0c34\n\x0b\n\x04\x04\
    \x01\x02\x03\x12\x03\r\x08/\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03\r\
    \x08\x10\n\x0c\n\x05\x04\x01\x02\x03\x06\x12\x03\r\x11\x1d\n\x0c\n\x05\
    \x04\x01\x02\x03\x01\x12\x03\r\x1e*\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\
    \x03\r-.\n\x0b\n\x04\x04\x01\x02\x04\x12\x03\x0e\x081\n\x0c\n\x05\x04\
    \x01\x02\x04\x04\x12\x03\x0e\x08\x10\n\x0c\n\x05\x04\x01\x02\x04\x06\x12\
    \x03\x0e\x11\x1d\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03\x0e\x1e,\n\x0c\
    \n\x05\x04\x01\x02\x04\x03\x12\x03\x0e/0\n\x0b\n\x04\x04\x01\x02\x05\x12\
    \x03\x0f\x08-\n\x0c\n\x05\x04\x01\x02\x05\x04\x12\x03\x0f\x08\x10\n\x0c\
    \n\x05\x04\x01\x02\x05\x05\x12\x03\x0f\x11\x17\n\x0c\n\x05\x04\x01\x02\
    \x05\x01\x12\x03\x0f\x18(\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x03\x0f+,\
    \n\x0b\n\x04\x04\x01\x02\x06\x12\x03\x10\x08\x20\n\x0c\n\x05\x04\x01\x02\
    \x06\x04\x12\x03\x10\x08\x10\n\x0c\n\x05\x04\x01\x02\x06\x05\x12\x03\x10\
    \x11\x16\n\x0c\n\x05\x04\x01\x02\x06\x01\x12\x03\x10\x17\x1b\n\x0c\n\x05\
    \x04\x01\x02\x06\x03\x12\x03\x10\x1e\x1f\n\x0b\n\x04\x04\x01\x02\x07\x12\
    \x03\x11\x08(\n\x0c\n\x05\x04\x01\x02\x07\x04\x12\x03\x11\x08\x10\n\x0c\
    \n\x05\x04\x01\x02\x07\x05\x12\x03\x11\x11\x16\n\x0c\n\x05\x04\x01\x02\
    \x07\x01\x12\x03\x11\x17#\n\x0c\n\x05\x04\x01\x02\x07\x03\x12\x03\x11&'\
    \n\x0b\n\x04\x04\x01\x02\x08\x12\x03\x12\x08%\n\x0c\n\x05\x04\x01\x02\
    \x08\x04\x12\x03\x12\x08\x10\n\x0c\n\x05\x04\x01\x02\x08\x05\x12\x03\x12\
    \x11\x15\n\x0c\n\x05\x04\x01\x02\x08\x01\x12\x03\x12\x16\x20\n\x0c\n\x05\
    \x04\x01\x02\x08\x03\x12\x03\x12#$\n\x0b\n\x04\x04\x01\x02\t\x12\x03\x13\
    \x08.\n\x0c\n\x05\x04\x01\x02\t\x04\x12\x03\x13\x08\x10\n\x0c\n\x05\x04\
    \x01\x02\t\x05\x12\x03\x13\x11\x17\n\x0c\n\x05\x04\x01\x02\t\x01\x12\x03\
    \x13\x18(\n\x0c\n\x05\x04\x01\x02\t\x03\x12\x03\x13+-\n\x0b\n\x04\x04\
    \x01\x02\n\x12\x03\x14\x08,\n\x0c\n\x05\x04\x01\x02\n\x04\x12\x03\x14\
    \x08\x10\n\x0c\n\x05\x04\x01\x02\n\x05\x12\x03\x14\x11\x17\n\x0c\n\x05\
    \x04\x01\x02\n\x01\x12\x03\x14\x18&\n\x0c\n\x05\x04\x01\x02\n\x03\x12\
    \x03\x14)+\n\x0b\n\x04\x04\x01\x02\x0b\x12\x03\x15\x080\n\x0c\n\x05\x04\
    \x01\x02\x0b\x04\x12\x03\x15\x08\x10\n\x0c\n\x05\x04\x01\x02\x0b\x05\x12\
    \x03\x15\x11\x15\n\x0c\n\x05\x04\x01\x02\x0b\x01\x12\x03\x15\x16*\n\x0c\
    \n\x05\x04\x01\x02\x0b\x03\x12\x03\x15-/\n\n\n\x02\x04\x02\x12\x04\x18\0\
    \x1e\x01\n\n\n\x03\x04\x02\x01\x12\x03\x18\x080\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\x17\n\x0c\n\x05\x04\x02\x02\
    \0\x01\x12\x03\x19\x18\x20\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x19#$\n\
    \x0b\n\x04\x04\x02\x02\x01\x12\x03\x1a\x080\n\x0c\n\x05\x04\x02\x02\x01\
    \x04\x12\x03\x1a\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x06\x12\x03\x1a\x11\
    \"\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x1a#+\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\x17\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03\
    \x1b\x18!\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\x17\n\x0c\n\
    \x05\x04\x02\x02\x03\x01\x12\x03\x1c\x18\"\n\x0c\n\x05\x04\x02\x02\x03\
    \x03\x12\x03\x1c%&\n\x0b\n\x04\x04\x02\x02\x04\x12\x03\x1d\x08&\n\x0c\n\
    \x05\x04\x02\x02\x04\x04\x12\x03\x1d\x08\x10\n\x0c\n\x05\x04\x02\x02\x04\
    \x05\x12\x03\x1d\x11\x18\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03\x1d\x19\
    \x20\n\x0c\n\x05\x04\x02\x02\x04\x03\x12\x03\x1d#%\n\n\n\x02\x04\x03\x12\
    \x04\x20\0!\x01\n\n\n\x03\x04\x03\x01\x12\x03\x20\x081\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\x17\n\x0c\n\x05\x04\x04\x02\0\
    \x01\x12\x03$\x18\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\x20\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+\x08-\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\n\n\x02\x04\x07\x12\x04/\01\x01\n\n\n\x03\
    \x04\x07\x01\x12\x03/\x08.\n\x0b\n\x04\x04\x07\x02\0\x12\x030\x080\n\x0c\
    \n\x05\x04\x07\x02\0\x04\x12\x030\x08\x10\n\x0c\n\x05\x04\x07\x02\0\x06\
    \x12\x030\x11\"\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x030#+\n\x0c\n\x05\x04\
    \x07\x02\0\x03\x12\x030./\n\n\n\x02\x04\x08\x12\x043\05\x01\n\n\n\x03\
    \x04\x08\x01\x12\x033\x083\n\x0b\n\x04\x04\x08\x02\0\x12\x034\x08%\n\x0c\
    \n\x05\x04\x08\x02\0\x04\x12\x034\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\
    \x12\x034\x11\x17\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x034\x18\x20\n\x0c\n\
    \x05\x04\x08\x02\0\x03\x12\x034#$\n\n\n\x02\x04\t\x12\x047\0:\x01\n\n\n\
    \x03\x04\t\x01\x12\x037\x084\n\x0b\n\x04\x04\t\x02\0\x12\x038\x08/\n\x0c\
    \n\x05\x04\t\x02\0\x04\x12\x038\x08\x10\n\x0c\n\x05\x04\t\x02\0\x05\x12\
    \x038\x11\x16\n\x0c\n\x05\x04\t\x02\0\x01\x12\x038\x17*\n\x0c\n\x05\x04\
    \t\x02\0\x03\x12\x038-.\n\x0b\n\x04\x04\t\x02\x01\x12\x039\x08%\n\x0c\n\
    \x05\x04\t\x02\x01\x04\x12\x039\x08\x10\n\x0c\n\x05\x04\t\x02\x01\x05\
    \x12\x039\x11\x16\n\x0c\n\x05\x04\t\x02\x01\x01\x12\x039\x17\x20\n\x0c\n\
    \x05\x04\t\x02\x01\x03\x12\x039#$\n\n\n\x02\x04\n\x12\x04<\0B\x01\n\n\n\
    \x03\x04\n\x01\x12\x03<\x08-\n\x0b\n\x04\x04\n\x02\0\x12\x03=\x08%\n\x0c\
    \n\x05\x04\n\x02\0\x04\x12\x03=\x08\x10\n\x0c\n\x05\x04\n\x02\0\x05\x12\
    \x03=\x11\x17\n\x0c\n\x05\x04\n\x02\0\x01\x12\x03=\x18\x20\n\x0c\n\x05\
    \x04\n\x02\0\x03\x12\x03=#$\n\x0b\n\x04\x04\n\x02\x01\x12\x03>\x080\n\
    \x0c\n\x05\x04\n\x02\x01\x04\x12\x03>\x08\x10\n\x0c\n\x05\x04\n\x02\x01\
    \x06\x12\x03>\x11\"\n\x0c\n\x05\x04\n\x02\x01\x01\x12\x03>#+\n\x0c\n\x05\
    \x04\n\x02\x01\x03\x12\x03>./\n\x0b\n\x04\x04\n\x02\x02\x12\x03?\x08)\n\
    \x0c\n\x05\x04\n\x02\x02\x04\x12\x03?\x08\x10\n\x0c\n\x05\x04\n\x02\x02\
    \x05\x12\x03?\x11\x17\n\x0c\n\x05\x04\n\x02\x02\x01\x12\x03?\x18$\n\x0c\
    \n\x05\x04\n\x02\x02\x03\x12\x03?'(\n\x0b\n\x04\x04\n\x02\x03\x12\x03@\
    \x08&\n\x0c\n\x05\x04\n\x02\x03\x04\x12\x03@\x08\x10\n\x0c\n\x05\x04\n\
    \x02\x03\x05\x12\x03@\x11\x17\n\x0c\n\x05\x04\n\x02\x03\x01\x12\x03@\x18\
    !\n\x0c\n\x05\x04\n\x02\x03\x03\x12\x03@$%\n\x0b\n\x04\x04\n\x02\x04\x12\
    \x03A\x08&\n\x0c\n\x05\x04\n\x02\x04\x04\x12\x03A\x08\x10\n\x0c\n\x05\
    \x04\n\x02\x04\x05\x12\x03A\x11\x18\n\x0c\n\x05\x04\n\x02\x04\x01\x12\
    \x03A\x19\x20\n\x0c\n\x05\x04\n\x02\x04\x03\x12\x03A#%\n\n\n\x02\x04\x0b\
    \x12\x04D\0E\x01\n\n\n\x03\x04\x0b\x01\x12\x03D\x08.\n\n\n\x02\x04\x0c\
    \x12\x04G\0I\x01\n\n\n\x03\x04\x0c\x01\x12\x03G\x08'\n\x0b\n\x04\x04\x0c\
    \x02\0\x12\x03H\x08)\n\x0c\n\x05\x04\x0c\x02\0\x04\x12\x03H\x08\x10\n\
    \x0c\n\x05\x04\x0c\x02\0\x05\x12\x03H\x11\x17\n\x0c\n\x05\x04\x0c\x02\0\
    \x01\x12\x03H\x18$\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03H'(\n\n\n\x02\
    \x04\r\x12\x04K\0L\x01\n\n\n\x03\x04\r\x01\x12\x03K\x08(\n\n\n\x02\x04\
    \x0e\x12\x04N\0R\x01\n\n\n\x03\x04\x0e\x01\x12\x03N\x08*\n\x0b\n\x04\x04\
    \x0e\x02\0\x12\x03O\x08%\n\x0c\n\x05\x04\x0e\x02\0\x04\x12\x03O\x08\x10\
    \n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03O\x11\x17\n\x0c\n\x05\x04\x0e\x02\
    \0\x01\x12\x03O\x18\x20\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\x03O#$\n\x0b\n\
    \x04\x04\x0e\x02\x01\x12\x03P\x08$\n\x0c\n\x05\x04\x0e\x02\x01\x04\x12\
    \x03P\x08\x10\n\x0c\n\x05\x04\x0e\x02\x01\x05\x12\x03P\x11\x17\n\x0c\n\
    \x05\x04\x0e\x02\x01\x01\x12\x03P\x18\x1f\n\x0c\n\x05\x04\x0e\x02\x01\
    \x03\x12\x03P\"#\n\x0b\n\x04\x04\x0e\x02\x02\x12\x03Q\x081\n\x0c\n\x05\
    \x04\x0e\x02\x02\x04\x12\x03Q\x08\x10\n\x0c\n\x05\x04\x0e\x02\x02\x05\
    \x12\x03Q\x11\x15\n\x0c\n\x05\x04\x0e\x02\x02\x01\x12\x03Q\x16,\n\x0c\n\
    \x05\x04\x0e\x02\x02\x03\x12\x03Q/0\n\n\n\x02\x04\x0f\x12\x04T\0V\x01\n\
    \n\n\x03\x04\x0f\x01\x12\x03T\x08+\n\x0b\n\x04\x04\x0f\x02\0\x12\x03U\
    \x08\"\n\x0c\n\x05\x04\x0f\x02\0\x04\x12\x03U\x08\x10\n\x0c\n\x05\x04\
    \x0f\x02\0\x05\x12\x03U\x11\x17\n\x0c\n\x05\x04\x0f\x02\0\x01\x12\x03U\
    \x18\x1d\n\x0c\n\x05\x04\x0f\x02\0\x03\x12\x03U\x20!\n\n\n\x02\x04\x10\
    \x12\x04X\0Z\x01\n\n\n\x03\x04\x10\x01\x12\x03X\x08$\n\x0b\n\x04\x04\x10\
    \x02\0\x12\x03Y\x08$\n\x0c\n\x05\x04\x10\x02\0\x04\x12\x03Y\x08\x10\n\
    \x0c\n\x05\x04\x10\x02\0\x05\x12\x03Y\x11\x17\n\x0c\n\x05\x04\x10\x02\0\
    \x01\x12\x03Y\x18\x1f\n\x0c\n\x05\x04\x10\x02\0\x03\x12\x03Y\"#\n\n\n\
    \x02\x04\x11\x12\x04\\\0]\x01\n\n\n\x03\x04\x11\x01\x12\x03\\\x08%\n\n\n\
    \x02\x04\x12\x12\x04_\0`\x01\n\n\n\x03\x04\x12\x01\x12\x03_\x08-\n\n\n\
    \x02\x04\x13\x12\x04b\0c\x01\n\n\n\x03\x04\x13\x01\x12\x03b\x08.\n\n\n\
    \x02\x04\x14\x12\x04e\0h\x01\n\n\n\x03\x04\x14\x01\x12\x03e\x081\n\x0b\n\
    \x04\x04\x14\x02\0\x12\x03f\x08*\n\x0c\n\x05\x04\x14\x02\0\x04\x12\x03f\
    \x08\x10\n\x0c\n\x05\x04\x14\x02\0\x05\x12\x03f\x11\x17\n\x0c\n\x05\x04\
    \x14\x02\0\x01\x12\x03f\x18%\n\x0c\n\x05\x04\x14\x02\0\x03\x12\x03f()\n\
    \x0b\n\x04\x04\x14\x02\x01\x12\x03g\x08&\n\x0c\n\x05\x04\x14\x02\x01\x04\
    \x12\x03g\x08\x10\n\x0c\n\x05\x04\x14\x02\x01\x05\x12\x03g\x11\x18\n\x0c\
    \n\x05\x04\x14\x02\x01\x01\x12\x03g\x19\x20\n\x0c\n\x05\x04\x14\x02\x01\
    \x03\x12\x03g#%\n\n\n\x02\x04\x15\x12\x04j\0k\x01\n\n\n\x03\x04\x15\x01\
    \x12\x03j\x082\n\n\n\x02\x04\x16\x12\x04m\0r\x01\n\n\n\x03\x04\x16\x01\
    \x12\x03m\x085\n\x0b\n\x04\x04\x16\x02\0\x12\x03n\x08/\n\x0c\n\x05\x04\
    \x16\x02\0\x04\x12\x03n\x08\x10\n\x0c\n\x05\x04\x16\x02\0\x05\x12\x03n\
    \x11\x16\n\x0c\n\x05\x04\x16\x02\0\x01\x12\x03n\x17*\n\x0c\n\x05\x04\x16\
    \x02\0\x03\x12\x03n-.\n\x0b\n\x04\x04\x16\x02\x01\x12\x03o\x08%\n\x0c\n\
    \x05\x04\x16\x02\x01\x04\x12\x03o\x08\x10\n\x0c\n\x05\x04\x16\x02\x01\
    \x05\x12\x03o\x11\x16\n\x0c\n\x05\x04\x16\x02\x01\x01\x12\x03o\x17\x20\n\
    \x0c\n\x05\x04\x16\x02\x01\x03\x12\x03o#$\n\x0b\n\x04\x04\x16\x02\x02\
    \x12\x03p\x08%\n\x0c\n\x05\x04\x16\x02\x02\x04\x12\x03p\x08\x10\n\x0c\n\
    \x05\x04\x16\x02\x02\x05\x12\x03p\x11\x17\n\x0c\n\x05\x04\x16\x02\x02\
    \x01\x12\x03p\x18\x20\n\x0c\n\x05\x04\x16\x02\x02\x03\x12\x03p#$\n\x0b\n\
    \x04\x04\x16\x02\x03\x12\x03q\x08&\n\x0c\n\x05\x04\x16\x02\x03\x04\x12\
    \x03q\x08\x10\n\x0c\n\x05\x04\x16\x02\x03\x05\x12\x03q\x11\x17\n\x0c\n\
    \x05\x04\x16\x02\x03\x01\x12\x03q\x18!\n\x0c\n\x05\x04\x16\x02\x03\x03\
    \x12\x03q$%\n\n\n\x02\x04\x17\x12\x04t\0w\x01\n\n\n\x03\x04\x17\x01\x12\
    \x03t\x08-\n\x0b\n\x04\x04\x17\x02\0\x12\x03u\x08%\n\x0c\n\x05\x04\x17\
    \x02\0\x04\x12\x03u\x08\x10\n\x0c\n\x05\x04\x17\x02\0\x05\x12\x03u\x11\
    \x17\n\x0c\n\x05\x04\x17\x02\0\x01\x12\x03u\x18\x20\n\x0c\n\x05\x04\x17\
    \x02\0\x03\x12\x03u#$\n\x0b\n\x04\x04\x17\x02\x01\x12\x03v\x08&\n\x0c\n\
    \x05\x04\x17\x02\x01\x04\x12\x03v\x08\x10\n\x0c\n\x05\x04\x17\x02\x01\
    \x05\x12\x03v\x11\x17\n\x0c\n\x05\x04\x17\x02\x01\x01\x12\x03v\x18!\n\
    \x0c\n\x05\x04\x17\x02\x01\x03\x12\x03v$%\n\n\n\x02\x04\x18\x12\x04y\0{\
    \x01\n\n\n\x03\x04\x18\x01\x12\x03y\x08+\n\x0b\n\x04\x04\x18\x02\0\x12\
    \x03z\x08&\n\x0c\n\x05\x04\x18\x02\0\x04\x12\x03z\x08\x10\n\x0c\n\x05\
    \x04\x18\x02\0\x05\x12\x03z\x11\x17\n\x0c\n\x05\x04\x18\x02\0\x01\x12\
    \x03z\x18!\n\x0c\n\x05\x04\x18\x02\0\x03\x12\x03z$%\n\x0b\n\x02\x06\0\
    \x12\x05}\0\xa7\x01\x01\n\n\n\x03\x06\0\x01\x12\x03}\x08\x10\n\n\n\x03\
    \x06\0\x03\x12\x03~\x08C\n\r\n\x06\x06\0\x03\xd0\x86\x03\x12\x03~\x08C\n\
    \x0e\n\x04\x06\0\x02\0\x12\x06\x80\x01\x08\x82\x01\t\n\r\n\x05\x06\0\x02\
    \0\x01\x12\x04\x80\x01\x0c\"\n\r\n\x05\x06\0\x02\0\x02\x12\x04\x80\x01$M\
    \n\x0e\n\x05\x06\0\x02\0\x03\x12\x05\x80\x01X\x82\x01\n\x0e\n\x05\x06\0\
    \x02\0\x04\x12\x05\x81\x01\x10\x8c\x01\n\x11\n\x08\x06\0\x02\0\x04\xd0\
    \x86\x03\x12\x05\x81\x01\x10\x8c\x01\n\x0e\n\x04\x06\0\x02\x01\x12\x06\
    \x84\x01\x08\x86\x01\t\n\r\n\x05\x06\0\x02\x01\x01\x12\x04\x84\x01\x0c#\
    \n\r\n\x05\x06\0\x02\x01\x02\x12\x04\x84\x01%O\n\x0e\n\x05\x06\0\x02\x01\
    \x03\x12\x05\x84\x01Z\x85\x01\n\r\n\x05\x06\0\x02\x01\x04\x12\x04\x85\
    \x01\x10d\n\x10\n\x08\x06\0\x02\x01\x04\xd0\x86\x03\x12\x04\x85\x01\x10d\
    \n\x0e\n\x04\x06\0\x02\x02\x12\x06\x88\x01\x08\x8a\x01\t\n\r\n\x05\x06\0\
    \x02\x02\x01\x12\x04\x88\x01\x0c\x1f\n\r\n\x05\x06\0\x02\x02\x02\x12\x04\
    \x88\x01!G\n\r\n\x05\x06\0\x02\x02\x03\x12\x04\x88\x01Ry\n\r\n\x05\x06\0\
    \x02\x02\x04\x12\x04\x89\x01\x10l\n\x10\n\x08\x06\0\x02\x02\x04\xd0\x86\
    \x03\x12\x04\x89\x01\x10l\n\x0e\n\x04\x06\0\x02\x03\x12\x06\x8c\x01\x08\
    \x8e\x01\t\n\r\n\x05\x06\0\x02\x03\x01\x12\x04\x8c\x01\x0c%\n\r\n\x05\
    \x06\0\x02\x03\x02\x12\x04\x8c\x01'S\n\x0e\n\x05\x06\0\x02\x03\x03\x12\
    \x05\x8c\x01^\x8b\x01\n\x0e\n\x05\x06\0\x02\x03\x04\x12\x05\x8d\x01\x10\
    \x9b\x01\n\x11\n\x08\x06\0\x02\x03\x04\xd0\x86\x03\x12\x05\x8d\x01\x10\
    \x9b\x01\n\x0e\n\x04\x06\0\x02\x04\x12\x06\x90\x01\x08\x92\x01\t\n\r\n\
    \x05\x06\0\x02\x04\x01\x12\x04\x90\x01\x0c\x1f\n\r\n\x05\x06\0\x02\x04\
    \x02\x12\x04\x90\x01!G\n\r\n\x05\x06\0\x02\x04\x03\x12\x04\x90\x01Ry\n\r\
    \n\x05\x06\0\x02\x04\x04\x12\x04\x91\x01\x10l\n\x10\n\x08\x06\0\x02\x04\
    \x04\xd0\x86\x03\x12\x04\x91\x01\x10l\n\x0e\n\x04\x06\0\x02\x05\x12\x06\
    \x94\x01\x08\x96\x01\t\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\x94\x01\x0c\
    \x19\n\r\n\x05\x06\0\x02\x05\x02\x12\x04\x94\x01\x1b;\n\r\n\x05\x06\0\
    \x02\x05\x03\x12\x04\x94\x01Fg\n\r\n\x05\x06\0\x02\x05\x04\x12\x04\x95\
    \x01\x10~\n\x10\n\x08\x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\x95\x01\x10~\
    \n\x0e\n\x04\x06\0\x02\x06\x12\x06\x98\x01\x08\x9a\x01\t\n\r\n\x05\x06\0\
    \x02\x06\x01\x12\x04\x98\x01\x0c\x1c\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\
    \x98\x01\x1eA\n\r\n\x05\x06\0\x02\x06\x03\x12\x04\x98\x01Lp\n\x0e\n\x05\
    \x06\0\x02\x06\x04\x12\x05\x99\x01\x10\x85\x01\n\x11\n\x08\x06\0\x02\x06\
    \x04\xd0\x86\x03\x12\x05\x99\x01\x10\x85\x01\n\x0e\n\x04\x06\0\x02\x07\
    \x12\x06\x9c\x01\x08\x9e\x01\t\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\x9c\
    \x01\x0c\x16\n\r\n\x05\x06\0\x02\x07\x02\x12\x04\x9c\x01\x185\n\r\n\x05\
    \x06\0\x02\x07\x03\x12\x04\x9c\x01@^\n\r\n\x05\x06\0\x02\x07\x04\x12\x04\
    \x9d\x01\x10o\n\x10\n\x08\x06\0\x02\x07\x04\xd0\x86\x03\x12\x04\x9d\x01\
    \x10o\n\x0e\n\x04\x06\0\x02\x08\x12\x06\xa0\x01\x08\xa2\x01\t\n\r\n\x05\
    \x06\0\x02\x08\x01\x12\x04\xa0\x01\x0c\x1f\n\r\n\x05\x06\0\x02\x08\x02\
    \x12\x04\xa0\x01!G\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\xa0\x01Ry\n\x0e\n\
    \x05\x06\0\x02\x08\x04\x12\x05\xa1\x01\x10\x88\x01\n\x11\n\x08\x06\0\x02\
    \x08\x04\xd0\x86\x03\x12\x05\xa1\x01\x10\x88\x01\n\x0e\n\x04\x06\0\x02\t\
    \x12\x06\xa4\x01\x08\xa6\x01\t\n\r\n\x05\x06\0\x02\t\x01\x12\x04\xa4\x01\
    \x0c#\n\r\n\x05\x06\0\x02\t\x02\x12\x04\xa4\x01%O\n\x0e\n\x05\x06\0\x02\
    \t\x03\x12\x05\xa4\x01Z\x85\x01\n\r\n\x05\x06\0\x02\t\x04\x12\x04\xa5\
    \x01\x10c\n\x10\n\x08\x06\0\x02\t\x04\xd0\x86\x03\x12\x04\xa5\x01\x10c\n\
    \x0c\n\x02\x06\x01\x12\x06\xa9\x01\0\xb8\x01\x01\n\x0b\n\x03\x06\x01\x01\
    \x12\x04\xa9\x01\x08\x16\n\x0b\n\x03\x06\x01\x03\x12\x04\xaa\x01\x08P\n\
    \x0e\n\x06\x06\x01\x03\xd0\x86\x03\x12\x04\xaa\x01\x08P\n\x0b\n\x03\x06\
    \x01\x03\x12\x04\xab\x01\x08K\n\x0e\n\x06\x06\x01\x03\xd8\x86\x03\x12\
    \x04\xab\x01\x08K\n\x0e\n\x04\x06\x01\x02\0\x12\x06\xad\x01\x08\xaf\x01\
    \t\n\r\n\x05\x06\x01\x02\0\x01\x12\x04\xad\x01\x0c\x20\n\r\n\x05\x06\x01\
    \x02\0\x02\x12\x04\xad\x01\"P\n\r\n\x05\x06\x01\x02\0\x03\x12\x04\xad\
    \x01[f\n\r\n\x05\x06\x01\x02\0\x04\x12\x04\xae\x01\x10t\n\x10\n\x08\x06\
    \x01\x02\0\x04\xd0\x86\x03\x12\x04\xae\x01\x10t\n\x0e\n\x04\x06\x01\x02\
    \x01\x12\x06\xb1\x01\x08\xb3\x01\t\n\r\n\x05\x06\x01\x02\x01\x01\x12\x04\
    \xb1\x01\x0c\x18\n\r\n\x05\x06\x01\x02\x01\x02\x12\x04\xb1\x01\x1a@\n\r\
    \n\x05\x06\x01\x02\x01\x03\x12\x04\xb1\x01KV\n\r\n\x05\x06\x01\x02\x01\
    \x04\x12\x04\xb2\x01\x10|\n\x10\n\x08\x06\x01\x02\x01\x04\xd0\x86\x03\
    \x12\x04\xb2\x01\x10|\n\x0e\n\x04\x06\x01\x02\x02\x12\x06\xb5\x01\x08\
    \xb7\x01\t\n\r\n\x05\x06\x01\x02\x02\x01\x12\x04\xb5\x01\x0c\x16\n\r\n\
    \x05\x06\x01\x02\x02\x02\x12\x04\xb5\x01\x18<\n\r\n\x05\x06\x01\x02\x02\
    \x03\x12\x04\xb5\x01GR\n\r\n\x05\x06\x01\x02\x02\x04\x12\x04\xb6\x01\x10\
    y\n\x10\n\x08\x06\x01\x02\x02\x04\xd0\x86\x03\x12\x04\xb6\x01\x10y\
";

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