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_twofactor.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 CTwoFactor_Status_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 CTwoFactor_Status_Request {
    fn default() -> &'a CTwoFactor_Status_Request {
        <CTwoFactor_Status_Request as ::protobuf::Message>::default_instance()
    }
}

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

    // optional fixed64 steamid = 1;


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CTwoFactor_Status_Response {
    // message fields
    state: ::std::option::Option<u32>,
    inactivation_reason: ::std::option::Option<u32>,
    authenticator_type: ::std::option::Option<u32>,
    authenticator_allowed: ::std::option::Option<bool>,
    steamguard_scheme: ::std::option::Option<u32>,
    token_gid: ::protobuf::SingularField<::std::string::String>,
    email_validated: ::std::option::Option<bool>,
    device_identifier: ::protobuf::SingularField<::std::string::String>,
    time_created: ::std::option::Option<u32>,
    revocation_attempts_remaining: ::std::option::Option<u32>,
    classified_agent: ::protobuf::SingularField<::std::string::String>,
    allow_external_authenticator: ::std::option::Option<bool>,
    time_transferred: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 state = 1;


    pub fn get_state(&self) -> u32 {
        self.state.unwrap_or(0)
    }
    pub fn clear_state(&mut self) {
        self.state = ::std::option::Option::None;
    }

    pub fn has_state(&self) -> bool {
        self.state.is_some()
    }

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

    // optional uint32 inactivation_reason = 2;


    pub fn get_inactivation_reason(&self) -> u32 {
        self.inactivation_reason.unwrap_or(0)
    }
    pub fn clear_inactivation_reason(&mut self) {
        self.inactivation_reason = ::std::option::Option::None;
    }

    pub fn has_inactivation_reason(&self) -> bool {
        self.inactivation_reason.is_some()
    }

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

    // optional uint32 authenticator_type = 3;


    pub fn get_authenticator_type(&self) -> u32 {
        self.authenticator_type.unwrap_or(0)
    }
    pub fn clear_authenticator_type(&mut self) {
        self.authenticator_type = ::std::option::Option::None;
    }

    pub fn has_authenticator_type(&self) -> bool {
        self.authenticator_type.is_some()
    }

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

    // optional bool authenticator_allowed = 4;


    pub fn get_authenticator_allowed(&self) -> bool {
        self.authenticator_allowed.unwrap_or(false)
    }
    pub fn clear_authenticator_allowed(&mut self) {
        self.authenticator_allowed = ::std::option::Option::None;
    }

    pub fn has_authenticator_allowed(&self) -> bool {
        self.authenticator_allowed.is_some()
    }

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

    // optional uint32 steamguard_scheme = 5;


    pub fn get_steamguard_scheme(&self) -> u32 {
        self.steamguard_scheme.unwrap_or(0)
    }
    pub fn clear_steamguard_scheme(&mut self) {
        self.steamguard_scheme = ::std::option::Option::None;
    }

    pub fn has_steamguard_scheme(&self) -> bool {
        self.steamguard_scheme.is_some()
    }

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

    // optional string token_gid = 6;


    pub fn get_token_gid(&self) -> &str {
        match self.token_gid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_token_gid(&mut self) {
        self.token_gid.clear();
    }

    pub fn has_token_gid(&self) -> bool {
        self.token_gid.is_some()
    }

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

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

    // optional bool email_validated = 7;


    pub fn get_email_validated(&self) -> bool {
        self.email_validated.unwrap_or(false)
    }
    pub fn clear_email_validated(&mut self) {
        self.email_validated = ::std::option::Option::None;
    }

    pub fn has_email_validated(&self) -> bool {
        self.email_validated.is_some()
    }

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

    // optional string device_identifier = 8;


    pub fn get_device_identifier(&self) -> &str {
        match self.device_identifier.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_device_identifier(&mut self) {
        self.device_identifier.clear();
    }

    pub fn has_device_identifier(&self) -> bool {
        self.device_identifier.is_some()
    }

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

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

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

    // optional uint32 time_created = 9;


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

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

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

    // optional uint32 revocation_attempts_remaining = 10;


    pub fn get_revocation_attempts_remaining(&self) -> u32 {
        self.revocation_attempts_remaining.unwrap_or(0)
    }
    pub fn clear_revocation_attempts_remaining(&mut self) {
        self.revocation_attempts_remaining = ::std::option::Option::None;
    }

    pub fn has_revocation_attempts_remaining(&self) -> bool {
        self.revocation_attempts_remaining.is_some()
    }

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

    // optional string classified_agent = 11;


    pub fn get_classified_agent(&self) -> &str {
        match self.classified_agent.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_classified_agent(&mut self) {
        self.classified_agent.clear();
    }

    pub fn has_classified_agent(&self) -> bool {
        self.classified_agent.is_some()
    }

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

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

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

    // optional bool allow_external_authenticator = 12;


    pub fn get_allow_external_authenticator(&self) -> bool {
        self.allow_external_authenticator.unwrap_or(false)
    }
    pub fn clear_allow_external_authenticator(&mut self) {
        self.allow_external_authenticator = ::std::option::Option::None;
    }

    pub fn has_allow_external_authenticator(&self) -> bool {
        self.allow_external_authenticator.is_some()
    }

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

    // optional uint32 time_transferred = 13;


    pub fn get_time_transferred(&self) -> u32 {
        self.time_transferred.unwrap_or(0)
    }
    pub fn clear_time_transferred(&mut self) {
        self.time_transferred = ::std::option::Option::None;
    }

    pub fn has_time_transferred(&self) -> bool {
        self.time_transferred.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.state = ::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.inactivation_reason = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.authenticator_type = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.authenticator_allowed = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.steamguard_scheme = ::std::option::Option::Some(tmp);
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.token_gid)?;
                },
                7 => {
                    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.email_validated = ::std::option::Option::Some(tmp);
                },
                8 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_identifier)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.time_created = ::std::option::Option::Some(tmp);
                },
                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.revocation_attempts_remaining = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.classified_agent)?;
                },
                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.allow_external_authenticator = ::std::option::Option::Some(tmp);
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.time_transferred = ::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.state {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.inactivation_reason {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.authenticator_type {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.authenticator_allowed {
            my_size += 2;
        }
        if let Some(v) = self.steamguard_scheme {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.token_gid.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.email_validated {
            my_size += 2;
        }
        if let Some(ref v) = self.device_identifier.as_ref() {
            my_size += ::protobuf::rt::string_size(8, &v);
        }
        if let Some(v) = self.time_created {
            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.revocation_attempts_remaining {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.classified_agent.as_ref() {
            my_size += ::protobuf::rt::string_size(11, &v);
        }
        if let Some(v) = self.allow_external_authenticator {
            my_size += 2;
        }
        if let Some(v) = self.time_transferred {
            my_size += ::protobuf::rt::value_size(13, 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.state {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.inactivation_reason {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.authenticator_type {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.authenticator_allowed {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.steamguard_scheme {
            os.write_uint32(5, v)?;
        }
        if let Some(ref v) = self.token_gid.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(v) = self.email_validated {
            os.write_bool(7, v)?;
        }
        if let Some(ref v) = self.device_identifier.as_ref() {
            os.write_string(8, &v)?;
        }
        if let Some(v) = self.time_created {
            os.write_uint32(9, v)?;
        }
        if let Some(v) = self.revocation_attempts_remaining {
            os.write_uint32(10, v)?;
        }
        if let Some(ref v) = self.classified_agent.as_ref() {
            os.write_string(11, &v)?;
        }
        if let Some(v) = self.allow_external_authenticator {
            os.write_bool(12, v)?;
        }
        if let Some(v) = self.time_transferred {
            os.write_uint32(13, 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() -> CTwoFactor_Status_Response {
        CTwoFactor_Status_Response::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "state",
                |m: &CTwoFactor_Status_Response| { &m.state },
                |m: &mut CTwoFactor_Status_Response| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "inactivation_reason",
                |m: &CTwoFactor_Status_Response| { &m.inactivation_reason },
                |m: &mut CTwoFactor_Status_Response| { &mut m.inactivation_reason },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "authenticator_type",
                |m: &CTwoFactor_Status_Response| { &m.authenticator_type },
                |m: &mut CTwoFactor_Status_Response| { &mut m.authenticator_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "authenticator_allowed",
                |m: &CTwoFactor_Status_Response| { &m.authenticator_allowed },
                |m: &mut CTwoFactor_Status_Response| { &mut m.authenticator_allowed },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "steamguard_scheme",
                |m: &CTwoFactor_Status_Response| { &m.steamguard_scheme },
                |m: &mut CTwoFactor_Status_Response| { &mut m.steamguard_scheme },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "token_gid",
                |m: &CTwoFactor_Status_Response| { &m.token_gid },
                |m: &mut CTwoFactor_Status_Response| { &mut m.token_gid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "email_validated",
                |m: &CTwoFactor_Status_Response| { &m.email_validated },
                |m: &mut CTwoFactor_Status_Response| { &mut m.email_validated },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "device_identifier",
                |m: &CTwoFactor_Status_Response| { &m.device_identifier },
                |m: &mut CTwoFactor_Status_Response| { &mut m.device_identifier },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time_created",
                |m: &CTwoFactor_Status_Response| { &m.time_created },
                |m: &mut CTwoFactor_Status_Response| { &mut m.time_created },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "revocation_attempts_remaining",
                |m: &CTwoFactor_Status_Response| { &m.revocation_attempts_remaining },
                |m: &mut CTwoFactor_Status_Response| { &mut m.revocation_attempts_remaining },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "classified_agent",
                |m: &CTwoFactor_Status_Response| { &m.classified_agent },
                |m: &mut CTwoFactor_Status_Response| { &mut m.classified_agent },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "allow_external_authenticator",
                |m: &CTwoFactor_Status_Response| { &m.allow_external_authenticator },
                |m: &mut CTwoFactor_Status_Response| { &mut m.allow_external_authenticator },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time_transferred",
                |m: &CTwoFactor_Status_Response| { &m.time_transferred },
                |m: &mut CTwoFactor_Status_Response| { &mut m.time_transferred },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_Status_Response>(
                "CTwoFactor_Status_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_Status_Response {
    fn clear(&mut self) {
        self.state = ::std::option::Option::None;
        self.inactivation_reason = ::std::option::Option::None;
        self.authenticator_type = ::std::option::Option::None;
        self.authenticator_allowed = ::std::option::Option::None;
        self.steamguard_scheme = ::std::option::Option::None;
        self.token_gid.clear();
        self.email_validated = ::std::option::Option::None;
        self.device_identifier.clear();
        self.time_created = ::std::option::Option::None;
        self.revocation_attempts_remaining = ::std::option::Option::None;
        self.classified_agent.clear();
        self.allow_external_authenticator = ::std::option::Option::None;
        self.time_transferred = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CTwoFactor_AddAuthenticator_Request {
    // message fields
    steamid: ::std::option::Option<u64>,
    authenticator_time: ::std::option::Option<u64>,
    serial_number: ::std::option::Option<u64>,
    authenticator_type: ::std::option::Option<u32>,
    device_identifier: ::protobuf::SingularField<::std::string::String>,
    sms_phone_id: ::protobuf::SingularField<::std::string::String>,
    pub http_headers: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional fixed64 steamid = 1;


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

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

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

    // optional uint64 authenticator_time = 2;


    pub fn get_authenticator_time(&self) -> u64 {
        self.authenticator_time.unwrap_or(0)
    }
    pub fn clear_authenticator_time(&mut self) {
        self.authenticator_time = ::std::option::Option::None;
    }

    pub fn has_authenticator_time(&self) -> bool {
        self.authenticator_time.is_some()
    }

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

    // optional fixed64 serial_number = 3;


    pub fn get_serial_number(&self) -> u64 {
        self.serial_number.unwrap_or(0)
    }
    pub fn clear_serial_number(&mut self) {
        self.serial_number = ::std::option::Option::None;
    }

    pub fn has_serial_number(&self) -> bool {
        self.serial_number.is_some()
    }

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

    // optional uint32 authenticator_type = 4;


    pub fn get_authenticator_type(&self) -> u32 {
        self.authenticator_type.unwrap_or(0)
    }
    pub fn clear_authenticator_type(&mut self) {
        self.authenticator_type = ::std::option::Option::None;
    }

    pub fn has_authenticator_type(&self) -> bool {
        self.authenticator_type.is_some()
    }

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

    // optional string device_identifier = 5;


    pub fn get_device_identifier(&self) -> &str {
        match self.device_identifier.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_device_identifier(&mut self) {
        self.device_identifier.clear();
    }

    pub fn has_device_identifier(&self) -> bool {
        self.device_identifier.is_some()
    }

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

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

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

    // optional string sms_phone_id = 6;


    pub fn get_sms_phone_id(&self) -> &str {
        match self.sms_phone_id.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sms_phone_id(&mut self) {
        self.sms_phone_id.clear();
    }

    pub fn has_sms_phone_id(&self) -> bool {
        self.sms_phone_id.is_some()
    }

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

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

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

    // repeated string http_headers = 7;


    pub fn get_http_headers(&self) -> &[::std::string::String] {
        &self.http_headers
    }
    pub fn clear_http_headers(&mut self) {
        self.http_headers.clear();
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.authenticator_time = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.serial_number = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.authenticator_type = ::std::option::Option::Some(tmp);
                },
                5 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_identifier)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sms_phone_id)?;
                },
                7 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.http_headers)?;
                },
                _ => {
                    ::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.authenticator_time {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.serial_number {
            my_size += 9;
        }
        if let Some(v) = self.authenticator_type {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.device_identifier.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(ref v) = self.sms_phone_id.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        for value in &self.http_headers {
            my_size += ::protobuf::rt::string_size(7, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(v) = self.authenticator_time {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.serial_number {
            os.write_fixed64(3, v)?;
        }
        if let Some(v) = self.authenticator_type {
            os.write_uint32(4, v)?;
        }
        if let Some(ref v) = self.device_identifier.as_ref() {
            os.write_string(5, &v)?;
        }
        if let Some(ref v) = self.sms_phone_id.as_ref() {
            os.write_string(6, &v)?;
        }
        for v in &self.http_headers {
            os.write_string(7, &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() -> CTwoFactor_AddAuthenticator_Request {
        CTwoFactor_AddAuthenticator_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: &CTwoFactor_AddAuthenticator_Request| { &m.steamid },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "authenticator_time",
                |m: &CTwoFactor_AddAuthenticator_Request| { &m.authenticator_time },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.authenticator_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "serial_number",
                |m: &CTwoFactor_AddAuthenticator_Request| { &m.serial_number },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "authenticator_type",
                |m: &CTwoFactor_AddAuthenticator_Request| { &m.authenticator_type },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.authenticator_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "device_identifier",
                |m: &CTwoFactor_AddAuthenticator_Request| { &m.device_identifier },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.device_identifier },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sms_phone_id",
                |m: &CTwoFactor_AddAuthenticator_Request| { &m.sms_phone_id },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.sms_phone_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "http_headers",
                |m: &CTwoFactor_AddAuthenticator_Request| { &m.http_headers },
                |m: &mut CTwoFactor_AddAuthenticator_Request| { &mut m.http_headers },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_AddAuthenticator_Request>(
                "CTwoFactor_AddAuthenticator_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_AddAuthenticator_Request {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.authenticator_time = ::std::option::Option::None;
        self.serial_number = ::std::option::Option::None;
        self.authenticator_type = ::std::option::Option::None;
        self.device_identifier.clear();
        self.sms_phone_id.clear();
        self.http_headers.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CTwoFactor_AddAuthenticator_Response {
    // message fields
    shared_secret: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    serial_number: ::std::option::Option<u64>,
    revocation_code: ::protobuf::SingularField<::std::string::String>,
    uri: ::protobuf::SingularField<::std::string::String>,
    server_time: ::std::option::Option<u64>,
    account_name: ::protobuf::SingularField<::std::string::String>,
    token_gid: ::protobuf::SingularField<::std::string::String>,
    identity_secret: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    secret_1: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    status: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes shared_secret = 1;


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

    pub fn has_shared_secret(&self) -> bool {
        self.shared_secret.is_some()
    }

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

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

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

    // optional fixed64 serial_number = 2;


    pub fn get_serial_number(&self) -> u64 {
        self.serial_number.unwrap_or(0)
    }
    pub fn clear_serial_number(&mut self) {
        self.serial_number = ::std::option::Option::None;
    }

    pub fn has_serial_number(&self) -> bool {
        self.serial_number.is_some()
    }

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

    // optional string revocation_code = 3;


    pub fn get_revocation_code(&self) -> &str {
        match self.revocation_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_revocation_code(&mut self) {
        self.revocation_code.clear();
    }

    pub fn has_revocation_code(&self) -> bool {
        self.revocation_code.is_some()
    }

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

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

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

    // optional string uri = 4;


    pub fn get_uri(&self) -> &str {
        match self.uri.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_uri(&mut self) {
        self.uri.clear();
    }

    pub fn has_uri(&self) -> bool {
        self.uri.is_some()
    }

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

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

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

    // optional uint64 server_time = 5;


    pub fn get_server_time(&self) -> u64 {
        self.server_time.unwrap_or(0)
    }
    pub fn clear_server_time(&mut self) {
        self.server_time = ::std::option::Option::None;
    }

    pub fn has_server_time(&self) -> bool {
        self.server_time.is_some()
    }

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

    // optional string account_name = 6;


    pub fn get_account_name(&self) -> &str {
        match self.account_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_account_name(&mut self) {
        self.account_name.clear();
    }

    pub fn has_account_name(&self) -> bool {
        self.account_name.is_some()
    }

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

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

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

    // optional string token_gid = 7;


    pub fn get_token_gid(&self) -> &str {
        match self.token_gid.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_token_gid(&mut self) {
        self.token_gid.clear();
    }

    pub fn has_token_gid(&self) -> bool {
        self.token_gid.is_some()
    }

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

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

    // optional bytes identity_secret = 8;


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

    pub fn has_identity_secret(&self) -> bool {
        self.identity_secret.is_some()
    }

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

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

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

    // optional bytes secret_1 = 9;


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

    pub fn has_secret_1(&self) -> bool {
        self.secret_1.is_some()
    }

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

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

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

    // optional int32 status = 10;


    pub fn get_status(&self) -> i32 {
        self.status.unwrap_or(0)
    }
    pub fn clear_status(&mut self) {
        self.status = ::std::option::Option::None;
    }

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

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

impl ::protobuf::Message for CTwoFactor_AddAuthenticator_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.shared_secret)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.serial_number = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.revocation_code)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.server_time = ::std::option::Option::Some(tmp);
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.account_name)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.token_gid)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.identity_secret)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.secret_1)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.status = ::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.shared_secret.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.serial_number {
            my_size += 9;
        }
        if let Some(ref v) = self.revocation_code.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.uri.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.server_time {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.account_name.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(ref v) = self.token_gid.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(ref v) = self.identity_secret.as_ref() {
            my_size += ::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(ref v) = self.secret_1.as_ref() {
            my_size += ::protobuf::rt::bytes_size(9, &v);
        }
        if let Some(v) = self.status {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.shared_secret.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(v) = self.serial_number {
            os.write_fixed64(2, v)?;
        }
        if let Some(ref v) = self.revocation_code.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.uri.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.server_time {
            os.write_uint64(5, v)?;
        }
        if let Some(ref v) = self.account_name.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(ref v) = self.token_gid.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(ref v) = self.identity_secret.as_ref() {
            os.write_bytes(8, &v)?;
        }
        if let Some(ref v) = self.secret_1.as_ref() {
            os.write_bytes(9, &v)?;
        }
        if let Some(v) = self.status {
            os.write_int32(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CTwoFactor_AddAuthenticator_Response {
        CTwoFactor_AddAuthenticator_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>(
                "shared_secret",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.shared_secret },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.shared_secret },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "serial_number",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.serial_number },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.serial_number },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "revocation_code",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.revocation_code },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.revocation_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "uri",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.uri },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.uri },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "server_time",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.server_time },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.server_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "account_name",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.account_name },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.account_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "token_gid",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.token_gid },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.token_gid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "identity_secret",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.identity_secret },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.identity_secret },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "secret_1",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.secret_1 },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.secret_1 },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "status",
                |m: &CTwoFactor_AddAuthenticator_Response| { &m.status },
                |m: &mut CTwoFactor_AddAuthenticator_Response| { &mut m.status },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_AddAuthenticator_Response>(
                "CTwoFactor_AddAuthenticator_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_AddAuthenticator_Response {
    fn clear(&mut self) {
        self.shared_secret.clear();
        self.serial_number = ::std::option::Option::None;
        self.revocation_code.clear();
        self.uri.clear();
        self.server_time = ::std::option::Option::None;
        self.account_name.clear();
        self.token_gid.clear();
        self.identity_secret.clear();
        self.secret_1.clear();
        self.status = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional fixed64 steamid = 1;


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

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

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

    // optional uint32 email_type = 2;


    pub fn get_email_type(&self) -> u32 {
        self.email_type.unwrap_or(0)
    }
    pub fn clear_email_type(&mut self) {
        self.email_type = ::std::option::Option::None;
    }

    pub fn has_email_type(&self) -> bool {
        self.email_type.is_some()
    }

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

    // optional bool include_activation_code = 3;


    pub fn get_include_activation_code(&self) -> bool {
        self.include_activation_code.unwrap_or(false)
    }
    pub fn clear_include_activation_code(&mut self) {
        self.include_activation_code = ::std::option::Option::None;
    }

    pub fn has_include_activation_code(&self) -> bool {
        self.include_activation_code.is_some()
    }

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

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.steamid {
            my_size += 9;
        }
        if let Some(v) = self.email_type {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.include_activation_code {
            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.email_type {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.include_activation_code {
            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() -> CTwoFactor_SendEmail_Request {
        CTwoFactor_SendEmail_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: &CTwoFactor_SendEmail_Request| { &m.steamid },
                |m: &mut CTwoFactor_SendEmail_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "email_type",
                |m: &CTwoFactor_SendEmail_Request| { &m.email_type },
                |m: &mut CTwoFactor_SendEmail_Request| { &mut m.email_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "include_activation_code",
                |m: &CTwoFactor_SendEmail_Request| { &m.include_activation_code },
                |m: &mut CTwoFactor_SendEmail_Request| { &mut m.include_activation_code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_SendEmail_Request>(
                "CTwoFactor_SendEmail_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


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

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

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

    // optional string authenticator_code = 2;


    pub fn get_authenticator_code(&self) -> &str {
        match self.authenticator_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_authenticator_code(&mut self) {
        self.authenticator_code.clear();
    }

    pub fn has_authenticator_code(&self) -> bool {
        self.authenticator_code.is_some()
    }

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

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

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

    // optional uint64 authenticator_time = 3;


    pub fn get_authenticator_time(&self) -> u64 {
        self.authenticator_time.unwrap_or(0)
    }
    pub fn clear_authenticator_time(&mut self) {
        self.authenticator_time = ::std::option::Option::None;
    }

    pub fn has_authenticator_time(&self) -> bool {
        self.authenticator_time.is_some()
    }

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

    // optional string activation_code = 4;


    pub fn get_activation_code(&self) -> &str {
        match self.activation_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_activation_code(&mut self) {
        self.activation_code.clear();
    }

    pub fn has_activation_code(&self) -> bool {
        self.activation_code.is_some()
    }

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

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

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

    // repeated string http_headers = 5;


    pub fn get_http_headers(&self) -> &[::std::string::String] {
        &self.http_headers
    }
    pub fn clear_http_headers(&mut self) {
        self.http_headers.clear();
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_fixed64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.authenticator_code)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.authenticator_time = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.activation_code)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.http_headers)?;
                },
                _ => {
                    ::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(ref v) = self.authenticator_code.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.authenticator_time {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.activation_code.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        for value in &self.http_headers {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.steamid {
            os.write_fixed64(1, v)?;
        }
        if let Some(ref v) = self.authenticator_code.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.authenticator_time {
            os.write_uint64(3, v)?;
        }
        if let Some(ref v) = self.activation_code.as_ref() {
            os.write_string(4, &v)?;
        }
        for v in &self.http_headers {
            os.write_string(5, &v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CTwoFactor_FinalizeAddAuthenticator_Request {
        CTwoFactor_FinalizeAddAuthenticator_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: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.steamid },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "authenticator_code",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.authenticator_code },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.authenticator_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "authenticator_time",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.authenticator_time },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.authenticator_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "activation_code",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.activation_code },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.activation_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "http_headers",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Request| { &m.http_headers },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Request| { &mut m.http_headers },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_FinalizeAddAuthenticator_Request>(
                "CTwoFactor_FinalizeAddAuthenticator_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_FinalizeAddAuthenticator_Request {
    fn clear(&mut self) {
        self.steamid = ::std::option::Option::None;
        self.authenticator_code.clear();
        self.authenticator_time = ::std::option::Option::None;
        self.activation_code.clear();
        self.http_headers.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CTwoFactor_FinalizeAddAuthenticator_Response {
    // message fields
    success: ::std::option::Option<bool>,
    want_more: ::std::option::Option<bool>,
    server_time: ::std::option::Option<u64>,
    status: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool success = 1;


    pub fn get_success(&self) -> bool {
        self.success.unwrap_or(false)
    }
    pub fn clear_success(&mut self) {
        self.success = ::std::option::Option::None;
    }

    pub fn has_success(&self) -> bool {
        self.success.is_some()
    }

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

    // optional bool want_more = 2;


    pub fn get_want_more(&self) -> bool {
        self.want_more.unwrap_or(false)
    }
    pub fn clear_want_more(&mut self) {
        self.want_more = ::std::option::Option::None;
    }

    pub fn has_want_more(&self) -> bool {
        self.want_more.is_some()
    }

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

    // optional uint64 server_time = 3;


    pub fn get_server_time(&self) -> u64 {
        self.server_time.unwrap_or(0)
    }
    pub fn clear_server_time(&mut self) {
        self.server_time = ::std::option::Option::None;
    }

    pub fn has_server_time(&self) -> bool {
        self.server_time.is_some()
    }

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

    // optional int32 status = 4;


    pub fn get_status(&self) -> i32 {
        self.status.unwrap_or(0)
    }
    pub fn clear_status(&mut self) {
        self.status = ::std::option::Option::None;
    }

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.success = ::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.want_more = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.server_time = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.status = ::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.success {
            my_size += 2;
        }
        if let Some(v) = self.want_more {
            my_size += 2;
        }
        if let Some(v) = self.server_time {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.status {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.success {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.want_more {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.server_time {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.status {
            os.write_int32(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() -> CTwoFactor_FinalizeAddAuthenticator_Response {
        CTwoFactor_FinalizeAddAuthenticator_Response::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "success",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.success },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.success },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "want_more",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.want_more },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.want_more },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "server_time",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.server_time },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.server_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "status",
                |m: &CTwoFactor_FinalizeAddAuthenticator_Response| { &m.status },
                |m: &mut CTwoFactor_FinalizeAddAuthenticator_Response| { &mut m.status },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_FinalizeAddAuthenticator_Response>(
                "CTwoFactor_FinalizeAddAuthenticator_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_FinalizeAddAuthenticator_Response {
    fn clear(&mut self) {
        self.success = ::std::option::Option::None;
        self.want_more = ::std::option::Option::None;
        self.server_time = ::std::option::Option::None;
        self.status = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CTwoFactor_RemoveAuthenticator_Request {
    // message fields
    revocation_code: ::protobuf::SingularField<::std::string::String>,
    revocation_reason: ::std::option::Option<u32>,
    steamguard_scheme: ::std::option::Option<u32>,
    remove_all_steamguard_cookies: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string revocation_code = 2;


    pub fn get_revocation_code(&self) -> &str {
        match self.revocation_code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_revocation_code(&mut self) {
        self.revocation_code.clear();
    }

    pub fn has_revocation_code(&self) -> bool {
        self.revocation_code.is_some()
    }

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

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

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

    // optional uint32 revocation_reason = 5;


    pub fn get_revocation_reason(&self) -> u32 {
        self.revocation_reason.unwrap_or(0)
    }
    pub fn clear_revocation_reason(&mut self) {
        self.revocation_reason = ::std::option::Option::None;
    }

    pub fn has_revocation_reason(&self) -> bool {
        self.revocation_reason.is_some()
    }

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

    // optional uint32 steamguard_scheme = 6;


    pub fn get_steamguard_scheme(&self) -> u32 {
        self.steamguard_scheme.unwrap_or(0)
    }
    pub fn clear_steamguard_scheme(&mut self) {
        self.steamguard_scheme = ::std::option::Option::None;
    }

    pub fn has_steamguard_scheme(&self) -> bool {
        self.steamguard_scheme.is_some()
    }

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

    // optional bool remove_all_steamguard_cookies = 7;


    pub fn get_remove_all_steamguard_cookies(&self) -> bool {
        self.remove_all_steamguard_cookies.unwrap_or(false)
    }
    pub fn clear_remove_all_steamguard_cookies(&mut self) {
        self.remove_all_steamguard_cookies = ::std::option::Option::None;
    }

    pub fn has_remove_all_steamguard_cookies(&self) -> bool {
        self.remove_all_steamguard_cookies.is_some()
    }

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

impl ::protobuf::Message for CTwoFactor_RemoveAuthenticator_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 {
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.revocation_code)?;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.revocation_reason = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.steamguard_scheme = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.remove_all_steamguard_cookies = ::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.revocation_code.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.revocation_reason {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamguard_scheme {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.remove_all_steamguard_cookies {
            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.revocation_code.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.revocation_reason {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.steamguard_scheme {
            os.write_uint32(6, v)?;
        }
        if let Some(v) = self.remove_all_steamguard_cookies {
            os.write_bool(7, 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() -> CTwoFactor_RemoveAuthenticator_Request {
        CTwoFactor_RemoveAuthenticator_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>(
                "revocation_code",
                |m: &CTwoFactor_RemoveAuthenticator_Request| { &m.revocation_code },
                |m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.revocation_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "revocation_reason",
                |m: &CTwoFactor_RemoveAuthenticator_Request| { &m.revocation_reason },
                |m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.revocation_reason },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "steamguard_scheme",
                |m: &CTwoFactor_RemoveAuthenticator_Request| { &m.steamguard_scheme },
                |m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.steamguard_scheme },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "remove_all_steamguard_cookies",
                |m: &CTwoFactor_RemoveAuthenticator_Request| { &m.remove_all_steamguard_cookies },
                |m: &mut CTwoFactor_RemoveAuthenticator_Request| { &mut m.remove_all_steamguard_cookies },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_RemoveAuthenticator_Request>(
                "CTwoFactor_RemoveAuthenticator_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_RemoveAuthenticator_Request {
    fn clear(&mut self) {
        self.revocation_code.clear();
        self.revocation_reason = ::std::option::Option::None;
        self.steamguard_scheme = ::std::option::Option::None;
        self.remove_all_steamguard_cookies = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CTwoFactor_RemoveAuthenticator_Response {
    // message fields
    success: ::std::option::Option<bool>,
    server_time: ::std::option::Option<u64>,
    revocation_attempts_remaining: ::std::option::Option<u32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool success = 1;


    pub fn get_success(&self) -> bool {
        self.success.unwrap_or(false)
    }
    pub fn clear_success(&mut self) {
        self.success = ::std::option::Option::None;
    }

    pub fn has_success(&self) -> bool {
        self.success.is_some()
    }

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

    // optional uint64 server_time = 3;


    pub fn get_server_time(&self) -> u64 {
        self.server_time.unwrap_or(0)
    }
    pub fn clear_server_time(&mut self) {
        self.server_time = ::std::option::Option::None;
    }

    pub fn has_server_time(&self) -> bool {
        self.server_time.is_some()
    }

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

    // optional uint32 revocation_attempts_remaining = 5;


    pub fn get_revocation_attempts_remaining(&self) -> u32 {
        self.revocation_attempts_remaining.unwrap_or(0)
    }
    pub fn clear_revocation_attempts_remaining(&mut self) {
        self.revocation_attempts_remaining = ::std::option::Option::None;
    }

    pub fn has_revocation_attempts_remaining(&self) -> bool {
        self.revocation_attempts_remaining.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.success = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.server_time = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.revocation_attempts_remaining = ::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.success {
            my_size += 2;
        }
        if let Some(v) = self.server_time {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.revocation_attempts_remaining {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.success {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.server_time {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.revocation_attempts_remaining {
            os.write_uint32(5, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "success",
                |m: &CTwoFactor_RemoveAuthenticator_Response| { &m.success },
                |m: &mut CTwoFactor_RemoveAuthenticator_Response| { &mut m.success },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "server_time",
                |m: &CTwoFactor_RemoveAuthenticator_Response| { &m.server_time },
                |m: &mut CTwoFactor_RemoveAuthenticator_Response| { &mut m.server_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "revocation_attempts_remaining",
                |m: &CTwoFactor_RemoveAuthenticator_Response| { &m.revocation_attempts_remaining },
                |m: &mut CTwoFactor_RemoveAuthenticator_Response| { &mut m.revocation_attempts_remaining },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_RemoveAuthenticator_Response>(
                "CTwoFactor_RemoveAuthenticator_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CTwoFactor_RemoveAuthenticator_Response {
    fn clear(&mut self) {
        self.success = ::std::option::Option::None;
        self.server_time = ::std::option::Option::None;
        self.revocation_attempts_remaining = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional string code = 1;


    pub fn get_code(&self) -> &str {
        match self.code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_code(&mut self) {
        self.code.clear();
    }

    pub fn has_code(&self) -> bool {
        self.code.is_some()
    }

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

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

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

impl ::protobuf::Message for CTwoFactor_CreateEmergencyCodes_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.code)?;
                },
                _ => {
                    ::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.code.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.code.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() -> CTwoFactor_CreateEmergencyCodes_Request {
        CTwoFactor_CreateEmergencyCodes_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>(
                "code",
                |m: &CTwoFactor_CreateEmergencyCodes_Request| { &m.code },
                |m: &mut CTwoFactor_CreateEmergencyCodes_Request| { &mut m.code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_CreateEmergencyCodes_Request>(
                "CTwoFactor_CreateEmergencyCodes_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated string codes = 1;


    pub fn get_codes(&self) -> &[::std::string::String] {
        &self.codes
    }
    pub fn clear_codes(&mut self) {
        self.codes.clear();
    }

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.codes {
            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() -> CTwoFactor_CreateEmergencyCodes_Response {
        CTwoFactor_CreateEmergencyCodes_Response::new()
    }

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

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

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

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

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

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

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

    // optional fixed64 steamid = 1;


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional string code = 1;


    pub fn get_code(&self) -> &str {
        match self.code.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_code(&mut self) {
        self.code.clear();
    }

    pub fn has_code(&self) -> bool {
        self.code.is_some()
    }

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

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

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

impl ::protobuf::Message for CTwoFactor_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.code)?;
                },
                _ => {
                    ::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.code.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.code.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() -> CTwoFactor_ValidateToken_Request {
        CTwoFactor_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>(
                "code",
                |m: &CTwoFactor_ValidateToken_Request| { &m.code },
                |m: &mut CTwoFactor_ValidateToken_Request| { &mut m.code },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_ValidateToken_Request>(
                "CTwoFactor_ValidateToken_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional bool valid = 1;


    pub fn get_valid(&self) -> bool {
        self.valid.unwrap_or(false)
    }
    pub fn clear_valid(&mut self) {
        self.valid = ::std::option::Option::None;
    }

    pub fn has_valid(&self) -> bool {
        self.valid.is_some()
    }

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

impl ::protobuf::Message for CTwoFactor_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 {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.valid = ::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.valid {
            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.valid {
            os.write_bool(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CTwoFactor_ValidateToken_Response {
        CTwoFactor_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 mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "valid",
                |m: &CTwoFactor_ValidateToken_Response| { &m.valid },
                |m: &mut CTwoFactor_ValidateToken_Response| { &mut m.valid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CTwoFactor_ValidateToken_Response>(
                "CTwoFactor_ValidateToken_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n)steammessages_twofactor.steamclient.proto\x1a,steammessages_unified_b\
    ase.steamclient.proto\"I\n\x19CTwoFactor_Status_Request\x12,\n\x07steami\
    d\x18\x01\x20\x01(\x06R\x07steamidB\x12\x82\xb5\x18\x0esteamid\x20to\x20\
    use\"\xb1\t\n\x1aCTwoFactor_Status_Response\x12-\n\x05state\x18\x01\x20\
    \x01(\rR\x05stateB\x17\x82\xb5\x18\x13Authenticator\x20state\x12Q\n\x13i\
    nactivation_reason\x18\x02\x20\x01(\rR\x12inactivationReasonB\x20\x82\
    \xb5\x18\x1cInactivation\x20reason\x20(if\x20any)\x12H\n\x12authenticato\
    r_type\x18\x03\x20\x01(\rR\x11authenticatorTypeB\x19\x82\xb5\x18\x15Type\
    \x20of\x20authenticator\x12b\n\x15authenticator_allowed\x18\x04\x20\x01(\
    \x08R\x14authenticatorAllowedB-\x82\xb5\x18)Account\x20allowed\x20to\x20\
    have\x20an\x20authenticator?\x12M\n\x11steamguard_scheme\x18\x05\x20\x01\
    (\rR\x10steamguardSchemeB\x20\x82\xb5\x18\x1cSteam\x20Guard\x20scheme\
    \x20in\x20effect\x12K\n\ttoken_gid\x18\x06\x20\x01(\tR\x08tokenGidB.\x82\
    \xb5\x18*String\x20rep\x20of\x20token\x20GID\x20assigned\x20by\x20server\
    \x12R\n\x0femail_validated\x18\x07\x20\x01(\x08R\x0eemailValidatedB)\x82\
    \xb5\x18%Account\x20has\x20verified\x20email\x20capability\x12Q\n\x11dev\
    ice_identifier\x18\x08\x20\x01(\tR\x10deviceIdentifierB$\x82\xb5\x18\x20\
    Authenticator\x20(phone)\x20identifier\x12A\n\x0ctime_created\x18\t\x20\
    \x01(\rR\x0btimeCreatedB\x1e\x82\xb5\x18\x1aWhen\x20the\x20token\x20was\
    \x20created\x12t\n\x1drevocation_attempts_remaining\x18\n\x20\x01(\rR\
    \x1brevocationAttemptsRemainingB0\x82\xb5\x18,Number\x20of\x20revocation\
    \x20code\x20attempts\x20remaining\x12o\n\x10classified_agent\x18\x0b\x20\
    \x01(\tR\x0fclassifiedAgentBD\x82\xb5\x18@Agent\x20that\x20added\x20the\
    \x20authenticator\x20(e.g.,\x20ios\x20/\x20android\x20/\x20other)\x12\
    \x83\x01\n\x1callow_external_authenticator\x18\x0c\x20\x01(\x08R\x1aallo\
    wExternalAuthenticatorBA\x82\xb5\x18=Allow\x20a\x20third-party\x20authen\
    ticator\x20(in\x20addition\x20to\x20two-factor)\x12p\n\x10time_transferr\
    ed\x18\r\x20\x01(\rR\x0ftimeTransferredBE\x82\xb5\x18AWhen\x20the\x20tok\
    en\x20was\x20transferred\x20from\x20another\x20device,\x20if\x20applicab\
    le\"\x9a\x04\n#CTwoFactor_AddAuthenticator_Request\x12,\n\x07steamid\x18\
    \x01\x20\x01(\x06R\x07steamidB\x12\x82\xb5\x18\x0esteamid\x20to\x20use\
    \x12M\n\x12authenticator_time\x18\x02\x20\x01(\x04R\x11authenticatorTime\
    B\x1e\x82\xb5\x18\x1aCurrent\x20authenticator\x20time\x12M\n\rserial_num\
    ber\x18\x03\x20\x01(\x06R\x0cserialNumberB(\x82\xb5\x18$locally\x20compu\
    ted\x20serial\x20(deprecated)\x12E\n\x12authenticator_type\x18\x04\x20\
    \x01(\rR\x11authenticatorTypeB\x16\x82\xb5\x18\x12Authenticator\x20type\
    \x12I\n\x11device_identifier\x18\x05\x20\x01(\tR\x10deviceIdentifierB\
    \x1c\x82\xb5\x18\x18Authenticator\x20identifier\x12M\n\x0csms_phone_id\
    \x18\x06\x20\x01(\tR\nsmsPhoneIdB+\x82\xb5\x18'ID\x20of\x20phone\x20to\
    \x20use\x20for\x20SMS\x20verification\x12F\n\x0chttp_headers\x18\x07\x20\
    \x03(\tR\x0bhttpHeadersB#\x82\xb5\x18\x1fHTTP\x20headers\x20alternating\
    \x20by\x20K/V\"\xe8\x05\n$CTwoFactor_AddAuthenticator_Response\x12W\n\rs\
    hared_secret\x18\x01\x20\x01(\x0cR\x0csharedSecretB2\x82\xb5\x18.Shared\
    \x20secret\x20between\x20server\x20and\x20authenticator\x12W\n\rserial_n\
    umber\x18\x02\x20\x01(\x06R\x0cserialNumberB2\x82\xb5\x18.Authenticator\
    \x20serial\x20number\x20(unique\x20per\x20token)\x12N\n\x0frevocation_co\
    de\x18\x03\x20\x01(\tR\x0erevocationCodeB%\x82\xb5\x18!code\x20used\x20t\
    o\x20revoke\x20authenticator\x120\n\x03uri\x18\x04\x20\x01(\tR\x03uriB\
    \x1e\x82\xb5\x18\x1aURI\x20for\x20QR\x20code\x20generation\x128\n\x0bser\
    ver_time\x18\x05\x20\x01(\x04R\nserverTimeB\x17\x82\xb5\x18\x13Current\
    \x20server\x20time\x12N\n\x0caccount_name\x18\x06\x20\x01(\tR\x0baccount\
    NameB+\x82\xb5\x18'Account\x20name\x20to\x20display\x20on\x20token\x20cl\
    ient\x12=\n\ttoken_gid\x18\x07\x20\x01(\tR\x08tokenGidB\x20\x82\xb5\x18\
    \x1cToken\x20GID\x20assigned\x20by\x20server\x12f\n\x0fidentity_secret\
    \x18\x08\x20\x01(\x0cR\x0eidentitySecretB=\x82\xb5\x189Secret\x20used\
    \x20for\x20identity\x20attestation\x20(e.g.,\x20for\x20eventing)\x122\n\
    \x08secret_1\x18\t\x20\x01(\x0cR\x07secret1B\x17\x82\xb5\x18\x13Spare\
    \x20shared\x20secret\x12'\n\x06status\x18\n\x20\x01(\x05R\x06statusB\x0f\
    \x82\xb5\x18\x0bResult\x20code\"\x88\x02\n\x1cCTwoFactor_SendEmail_Reque\
    st\x12,\n\x07steamid\x18\x01\x20\x01(\x06R\x07steamidB\x12\x82\xb5\x18\
    \x0eSteamid\x20to\x20use\x12Q\n\nemail_type\x18\x02\x20\x01(\rR\temailTy\
    peB2\x82\xb5\x18.Type\x20of\x20email\x20to\x20send\x20(ETwoFactorEmailTy\
    pe::*)\x12g\n\x17include_activation_code\x18\x03\x20\x01(\x08R\x15includ\
    eActivationCodeB/\x82\xb5\x18+Include\x20activation\x20code\x20in\x20ema\
    il\x20parameters\"\x1f\n\x1dCTwoFactor_SendEmail_Response\"\x8f\x03\n+CT\
    woFactor_FinalizeAddAuthenticator_Request\x12,\n\x07steamid\x18\x01\x20\
    \x01(\x06R\x07steamidB\x12\x82\xb5\x18\x0esteamid\x20to\x20use\x12D\n\
    \x12authenticator_code\x18\x02\x20\x01(\tR\x11authenticatorCodeB\x15\x82\
    \xb5\x18\x11Current\x20auth\x20code\x12M\n\x12authenticator_time\x18\x03\
    \x20\x01(\x04R\x11authenticatorTimeB\x1e\x82\xb5\x18\x1aCurrent\x20authe\
    nticator\x20time\x12U\n\x0factivation_code\x18\x04\x20\x01(\tR\x0eactiva\
    tionCodeB,\x82\xb5\x18(Activation\x20code\x20from\x20out-of-band\x20mess\
    age\x12F\n\x0chttp_headers\x18\x05\x20\x03(\tR\x0bhttpHeadersB#\x82\xb5\
    \x18\x1fHTTP\x20headers\x20alternating\x20by\x20K/V\"\x90\x02\n,CTwoFact\
    or_FinalizeAddAuthenticator_Response\x12C\n\x07success\x18\x01\x20\x01(\
    \x08R\x07successB)\x82\xb5\x18%True\x20if\x20succeeded,\x20or\x20want\
    \x20more\x20tries\x128\n\twant_more\x18\x02\x20\x01(\x08R\x08wantMoreB\
    \x1b\x82\xb5\x18\x17True\x20if\x20want\x20more\x20tries\x128\n\x0bserver\
    _time\x18\x03\x20\x01(\x04R\nserverTimeB\x17\x82\xb5\x18\x13Current\x20s\
    erver\x20time\x12'\n\x06status\x18\x04\x20\x01(\x05R\x06statusB\x0f\x82\
    \xb5\x18\x0bResult\x20code\"\x9b\x03\n&CTwoFactor_RemoveAuthenticator_Re\
    quest\x12L\n\x0frevocation_code\x18\x02\x20\x01(\tR\x0erevocationCodeB#\
    \x82\xb5\x18\x1fPassword\x20needed\x20to\x20remove\x20token\x12Z\n\x11re\
    vocation_reason\x18\x05\x20\x01(\rR\x10revocationReasonB-\x82\xb5\x18)Re\
    ason\x20the\x20authenticator\x20is\x20being\x20removed\x12a\n\x11steamgu\
    ard_scheme\x18\x06\x20\x01(\rR\x10steamguardSchemeB4\x82\xb5\x180Type\
    \x20of\x20Steam\x20Guard\x20to\x20use\x20once\x20token\x20is\x20removed\
    \x12d\n\x1dremove_all_steamguard_cookies\x18\x07\x20\x01(\x08R\x1aremove\
    AllSteamguardCookiesB!\x82\xb5\x18\x1dRemove\x20all\x20steamguard\x20coo\
    kies\"\xb0\x02\n'CTwoFactor_RemoveAuthenticator_Response\x12U\n\x07succe\
    ss\x18\x01\x20\x01(\x08R\x07successB;\x82\xb5\x187True\x20if\x20request\
    \x20succeeeded.\x20The\x20mobile\x20app\x20checks\x20this.\x128\n\x0bser\
    ver_time\x18\x03\x20\x01(\x04R\nserverTimeB\x17\x82\xb5\x18\x13Current\
    \x20server\x20time\x12t\n\x1drevocation_attempts_remaining\x18\x05\x20\
    \x01(\rR\x1brevocationAttemptsRemainingB0\x82\xb5\x18,Number\x20of\x20re\
    vocation\x20code\x20attempts\x20remaining\"=\n'CTwoFactor_CreateEmergenc\
    yCodes_Request\x12\x12\n\x04code\x18\x01\x20\x01(\tR\x04code\"U\n(CTwoFa\
    ctor_CreateEmergencyCodes_Response\x12)\n\x05codes\x18\x01\x20\x03(\tR\
    \x05codesB\x13\x82\xb5\x18\x0fEmergency\x20codes\"X\n(CTwoFactor_Destroy\
    EmergencyCodes_Request\x12,\n\x07steamid\x18\x01\x20\x01(\x06R\x07steami\
    dB\x12\x82\xb5\x18\x0esteamid\x20to\x20use\"+\n)CTwoFactor_DestroyEmerge\
    ncyCodes_Response\"L\n\x20CTwoFactor_ValidateToken_Request\x12(\n\x04cod\
    e\x18\x01\x20\x01(\tR\x04codeB\x14\x82\xb5\x18\x10code\x20to\x20validate\
    \"S\n!CTwoFactor_ValidateToken_Response\x12.\n\x05valid\x18\x01\x20\x01(\
    \x08R\x05validB\x18\x82\xb5\x18\x14result\x20of\x20validation2\x84\n\n\t\
    TwoFactor\x12\x8c\x01\n\x0bQueryStatus\x12\x1a.CTwoFactor_Status_Request\
    \x1a\x1b.CTwoFactor_Status_Response\"D\x82\xb5\x18@Get\x20two-factor\x20\
    authentication\x20settings\x20for\x20the\x20logged-in\x20account\x12\x9a\
    \x01\n\x10AddAuthenticator\x12$.CTwoFactor_AddAuthenticator_Request\x1a%\
    .CTwoFactor_AddAuthenticator_Response\"9\x82\xb5\x185Add\x20two-factor\
    \x20authenticator\x20to\x20the\x20logged-in\x20account\x12i\n\tSendEmail\
    \x12\x1d.CTwoFactor_SendEmail_Request\x1a\x1e.CTwoFactor_SendEmail_Respo\
    nse\"\x1d\x82\xb5\x18\x19Send\x20email\x20to\x20the\x20account\x12\xc1\
    \x01\n\x18FinalizeAddAuthenticator\x12,.CTwoFactor_FinalizeAddAuthentica\
    tor_Request\x1a-.CTwoFactor_FinalizeAddAuthenticator_Response\"H\x82\xb5\
    \x18DFinalize\x20two-factor\x20authentication\x20addition\x20to\x20the\
    \x20logged-in\x20account\x12\xb2\x01\n\x13RemoveAuthenticator\x12'.CTwoF\
    actor_RemoveAuthenticator_Request\x1a(.CTwoFactor_RemoveAuthenticator_Re\
    sponse\"H\x82\xb5\x18DRemove\x20two-factor\x20authentication\x20addition\
    \x20from\x20the\x20logged-in\x20account\x12\x97\x01\n\x14CreateEmergency\
    Codes\x12(.CTwoFactor_CreateEmergencyCodes_Request\x1a).CTwoFactor_Creat\
    eEmergencyCodes_Response\"*\x82\xb5\x18&Generate\x20emergency\x20authent\
    icator\x20codes\x12\xa9\x01\n\x15DestroyEmergencyCodes\x12).CTwoFactor_D\
    estroyEmergencyCodes_Request\x1a*.CTwoFactor_DestroyEmergencyCodes_Respo\
    nse\"9\x82\xb5\x185Destroy\x20emergency\x20authenticator\x20codes\x20for\
    \x20the\x20account\x12z\n\rValidateToken\x12!.CTwoFactor_ValidateToken_R\
    equest\x1a\".CTwoFactor_ValidateToken_Response\"\"\x82\xb5\x18\x1eValida\
    te\x20(and\x20consume)\x20a\x20token\x1a%\x82\xb5\x18!Two\x20Factor\x20A\
    uthentication\x20ServiceB\x03\x80\x01\x01J\x934\n\x07\x12\x05\0\0\x8d\
    \x01\x01\n\t\n\x02\x03\0\x12\x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\"\n\
    \t\n\x02\x08\x10\x12\x03\x02\0\"\n\n\n\x02\x04\0\x12\x04\x04\0\x06\x01\n\
    \n\n\x03\x04\0\x01\x12\x03\x04\x08!\n\x0b\n\x04\x04\0\x02\0\x12\x03\x05\
    \x08H\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\x05\x08\x10\n\x0c\n\x05\x04\0\
    \x02\0\x05\x12\x03\x05\x11\x18\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x05\
    \x19\x20\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x05#$\n\x0c\n\x05\x04\0\x02\
    \0\x08\x12\x03\x05%G\n\x0f\n\x08\x04\0\x02\0\x08\xd0\x86\x03\x12\x03\x05\
    &F\n\n\n\x02\x04\x01\x12\x04\x08\0\x16\x01\n\n\n\x03\x04\x01\x01\x12\x03\
    \x08\x08\"\n\x0b\n\x04\x04\x01\x02\0\x12\x03\t\x08J\n\x0c\n\x05\x04\x01\
    \x02\0\x04\x12\x03\t\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\t\x11\
    \x17\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\t\x18\x1d\n\x0c\n\x05\x04\x01\
    \x02\0\x03\x12\x03\t\x20!\n\x0c\n\x05\x04\x01\x02\0\x08\x12\x03\t\"I\n\
    \x0f\n\x08\x04\x01\x02\0\x08\xd0\x86\x03\x12\x03\t#H\n\x0b\n\x04\x04\x01\
    \x02\x01\x12\x03\n\x08a\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\n\x08\
    \x10\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\n\x11\x17\n\x0c\n\x05\x04\
    \x01\x02\x01\x01\x12\x03\n\x18+\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\
    \n./\n\x0c\n\x05\x04\x01\x02\x01\x08\x12\x03\n0`\n\x0f\n\x08\x04\x01\x02\
    \x01\x08\xd0\x86\x03\x12\x03\n1_\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x0b\
    \x08Y\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03\x0b\x08\x10\n\x0c\n\x05\
    \x04\x01\x02\x02\x05\x12\x03\x0b\x11\x17\n\x0c\n\x05\x04\x01\x02\x02\x01\
    \x12\x03\x0b\x18*\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x0b-.\n\x0c\n\
    \x05\x04\x01\x02\x02\x08\x12\x03\x0b/X\n\x0f\n\x08\x04\x01\x02\x02\x08\
    \xd0\x86\x03\x12\x03\x0b0W\n\x0b\n\x04\x04\x01\x02\x03\x12\x03\x0c\x08n\
    \n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03\x0c\x08\x10\n\x0c\n\x05\x04\x01\
    \x02\x03\x05\x12\x03\x0c\x11\x15\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\
    \x0c\x16+\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03\x0c./\n\x0c\n\x05\x04\
    \x01\x02\x03\x08\x12\x03\x0c0m\n\x0f\n\x08\x04\x01\x02\x03\x08\xd0\x86\
    \x03\x12\x03\x0c1l\n\x0b\n\x04\x04\x01\x02\x04\x12\x03\r\x08_\n\x0c\n\
    \x05\x04\x01\x02\x04\x04\x12\x03\r\x08\x10\n\x0c\n\x05\x04\x01\x02\x04\
    \x05\x12\x03\r\x11\x17\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03\r\x18)\n\
    \x0c\n\x05\x04\x01\x02\x04\x03\x12\x03\r,-\n\x0c\n\x05\x04\x01\x02\x04\
    \x08\x12\x03\r.^\n\x0f\n\x08\x04\x01\x02\x04\x08\xd0\x86\x03\x12\x03\r/]\
    \n\x0b\n\x04\x04\x01\x02\x05\x12\x03\x0e\x08e\n\x0c\n\x05\x04\x01\x02\
    \x05\x04\x12\x03\x0e\x08\x10\n\x0c\n\x05\x04\x01\x02\x05\x05\x12\x03\x0e\
    \x11\x17\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03\x0e\x18!\n\x0c\n\x05\
    \x04\x01\x02\x05\x03\x12\x03\x0e$%\n\x0c\n\x05\x04\x01\x02\x05\x08\x12\
    \x03\x0e&d\n\x0f\n\x08\x04\x01\x02\x05\x08\xd0\x86\x03\x12\x03\x0e'c\n\
    \x0b\n\x04\x04\x01\x02\x06\x12\x03\x0f\x08d\n\x0c\n\x05\x04\x01\x02\x06\
    \x04\x12\x03\x0f\x08\x10\n\x0c\n\x05\x04\x01\x02\x06\x05\x12\x03\x0f\x11\
    \x15\n\x0c\n\x05\x04\x01\x02\x06\x01\x12\x03\x0f\x16%\n\x0c\n\x05\x04\
    \x01\x02\x06\x03\x12\x03\x0f()\n\x0c\n\x05\x04\x01\x02\x06\x08\x12\x03\
    \x0f*c\n\x0f\n\x08\x04\x01\x02\x06\x08\xd0\x86\x03\x12\x03\x0f+b\n\x0b\n\
    \x04\x04\x01\x02\x07\x12\x03\x10\x08c\n\x0c\n\x05\x04\x01\x02\x07\x04\
    \x12\x03\x10\x08\x10\n\x0c\n\x05\x04\x01\x02\x07\x05\x12\x03\x10\x11\x17\
    \n\x0c\n\x05\x04\x01\x02\x07\x01\x12\x03\x10\x18)\n\x0c\n\x05\x04\x01\
    \x02\x07\x03\x12\x03\x10,-\n\x0c\n\x05\x04\x01\x02\x07\x08\x12\x03\x10.b\
    \n\x0f\n\x08\x04\x01\x02\x07\x08\xd0\x86\x03\x12\x03\x10/a\n\x0b\n\x04\
    \x04\x01\x02\x08\x12\x03\x11\x08X\n\x0c\n\x05\x04\x01\x02\x08\x04\x12\
    \x03\x11\x08\x10\n\x0c\n\x05\x04\x01\x02\x08\x05\x12\x03\x11\x11\x17\n\
    \x0c\n\x05\x04\x01\x02\x08\x01\x12\x03\x11\x18$\n\x0c\n\x05\x04\x01\x02\
    \x08\x03\x12\x03\x11'(\n\x0c\n\x05\x04\x01\x02\x08\x08\x12\x03\x11)W\n\
    \x0f\n\x08\x04\x01\x02\x08\x08\xd0\x86\x03\x12\x03\x11*V\n\x0b\n\x04\x04\
    \x01\x02\t\x12\x03\x12\x08|\n\x0c\n\x05\x04\x01\x02\t\x04\x12\x03\x12\
    \x08\x10\n\x0c\n\x05\x04\x01\x02\t\x05\x12\x03\x12\x11\x17\n\x0c\n\x05\
    \x04\x01\x02\t\x01\x12\x03\x12\x185\n\x0c\n\x05\x04\x01\x02\t\x03\x12\
    \x03\x128:\n\x0c\n\x05\x04\x01\x02\t\x08\x12\x03\x12;{\n\x0f\n\x08\x04\
    \x01\x02\t\x08\xd0\x86\x03\x12\x03\x12<z\n\x0c\n\x04\x04\x01\x02\n\x12\
    \x04\x13\x08\x83\x01\n\x0c\n\x05\x04\x01\x02\n\x04\x12\x03\x13\x08\x10\n\
    \x0c\n\x05\x04\x01\x02\n\x05\x12\x03\x13\x11\x17\n\x0c\n\x05\x04\x01\x02\
    \n\x01\x12\x03\x13\x18(\n\x0c\n\x05\x04\x01\x02\n\x03\x12\x03\x13+-\n\r\
    \n\x05\x04\x01\x02\n\x08\x12\x04\x13.\x82\x01\n\x10\n\x08\x04\x01\x02\n\
    \x08\xd0\x86\x03\x12\x04\x13/\x81\x01\n\x0c\n\x04\x04\x01\x02\x0b\x12\
    \x04\x14\x08\x8a\x01\n\x0c\n\x05\x04\x01\x02\x0b\x04\x12\x03\x14\x08\x10\
    \n\x0c\n\x05\x04\x01\x02\x0b\x05\x12\x03\x14\x11\x15\n\x0c\n\x05\x04\x01\
    \x02\x0b\x01\x12\x03\x14\x162\n\x0c\n\x05\x04\x01\x02\x0b\x03\x12\x03\
    \x1457\n\r\n\x05\x04\x01\x02\x0b\x08\x12\x04\x148\x89\x01\n\x10\n\x08\
    \x04\x01\x02\x0b\x08\xd0\x86\x03\x12\x04\x149\x88\x01\n\x0c\n\x04\x04\
    \x01\x02\x0c\x12\x04\x15\x08\x84\x01\n\x0c\n\x05\x04\x01\x02\x0c\x04\x12\
    \x03\x15\x08\x10\n\x0c\n\x05\x04\x01\x02\x0c\x05\x12\x03\x15\x11\x17\n\
    \x0c\n\x05\x04\x01\x02\x0c\x01\x12\x03\x15\x18(\n\x0c\n\x05\x04\x01\x02\
    \x0c\x03\x12\x03\x15+-\n\r\n\x05\x04\x01\x02\x0c\x08\x12\x04\x15.\x83\
    \x01\n\x10\n\x08\x04\x01\x02\x0c\x08\xd0\x86\x03\x12\x04\x15/\x82\x01\n\
    \n\n\x02\x04\x02\x12\x04\x18\0\x20\x01\n\n\n\x03\x04\x02\x01\x12\x03\x18\
    \x08+\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x19\x08H\n\x0c\n\x05\x04\x02\x02\
    \0\x04\x12\x03\x19\x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x19\x11\
    \x18\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\x19\x19\x20\n\x0c\n\x05\x04\
    \x02\x02\0\x03\x12\x03\x19#$\n\x0c\n\x05\x04\x02\x02\0\x08\x12\x03\x19%G\
    \n\x0f\n\x08\x04\x02\x02\0\x08\xd0\x86\x03\x12\x03\x19&F\n\x0b\n\x04\x04\
    \x02\x02\x01\x12\x03\x1a\x08^\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03\
    \x1a\x08\x10\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03\x1a\x11\x17\n\x0c\n\
    \x05\x04\x02\x02\x01\x01\x12\x03\x1a\x18*\n\x0c\n\x05\x04\x02\x02\x01\
    \x03\x12\x03\x1a-.\n\x0c\n\x05\x04\x02\x02\x01\x08\x12\x03\x1a/]\n\x0f\n\
    \x08\x04\x02\x02\x01\x08\xd0\x86\x03\x12\x03\x1a0\\\n\x0b\n\x04\x04\x02\
    \x02\x02\x12\x03\x1b\x08d\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x03\x1b\
    \x08\x10\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x03\x1b\x11\x18\n\x0c\n\x05\
    \x04\x02\x02\x02\x01\x12\x03\x1b\x19&\n\x0c\n\x05\x04\x02\x02\x02\x03\
    \x12\x03\x1b)*\n\x0c\n\x05\x04\x02\x02\x02\x08\x12\x03\x1b+c\n\x0f\n\x08\
    \x04\x02\x02\x02\x08\xd0\x86\x03\x12\x03\x1b,b\n\x0b\n\x04\x04\x02\x02\
    \x03\x12\x03\x1c\x08V\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\x0c\n\x05\x04\x02\x02\x03\x08\x12\x03\x1c/U\n\x0f\n\x08\x04\
    \x02\x02\x03\x08\xd0\x86\x03\x12\x03\x1c0T\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\x17\n\x0c\n\x05\x04\x02\
    \x02\x04\x01\x12\x03\x1d\x18)\n\x0c\n\x05\x04\x02\x02\x04\x03\x12\x03\
    \x1d,-\n\x0c\n\x05\x04\x02\x02\x04\x08\x12\x03\x1d.Z\n\x0f\n\x08\x04\x02\
    \x02\x04\x08\xd0\x86\x03\x12\x03\x1d/Y\n\x0b\n\x04\x04\x02\x02\x05\x12\
    \x03\x1e\x08e\n\x0c\n\x05\x04\x02\x02\x05\x04\x12\x03\x1e\x08\x10\n\x0c\
    \n\x05\x04\x02\x02\x05\x05\x12\x03\x1e\x11\x17\n\x0c\n\x05\x04\x02\x02\
    \x05\x01\x12\x03\x1e\x18$\n\x0c\n\x05\x04\x02\x02\x05\x03\x12\x03\x1e'(\
    \n\x0c\n\x05\x04\x02\x02\x05\x08\x12\x03\x1e)d\n\x0f\n\x08\x04\x02\x02\
    \x05\x08\xd0\x86\x03\x12\x03\x1e*c\n\x0b\n\x04\x04\x02\x02\x06\x12\x03\
    \x1f\x08]\n\x0c\n\x05\x04\x02\x02\x06\x04\x12\x03\x1f\x08\x10\n\x0c\n\
    \x05\x04\x02\x02\x06\x05\x12\x03\x1f\x11\x17\n\x0c\n\x05\x04\x02\x02\x06\
    \x01\x12\x03\x1f\x18$\n\x0c\n\x05\x04\x02\x02\x06\x03\x12\x03\x1f'(\n\
    \x0c\n\x05\x04\x02\x02\x06\x08\x12\x03\x1f)\\\n\x0f\n\x08\x04\x02\x02\
    \x06\x08\xd0\x86\x03\x12\x03\x1f*[\n\n\n\x02\x04\x03\x12\x04\"\0-\x01\n\
    \n\n\x03\x04\x03\x01\x12\x03\"\x08,\n\x0b\n\x04\x04\x03\x02\0\x12\x03#\
    \x08l\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03#\x08\x10\n\x0c\n\x05\x04\x03\
    \x02\0\x05\x12\x03#\x11\x16\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03#\x17$\
    \n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03#'(\n\x0c\n\x05\x04\x03\x02\0\x08\
    \x12\x03#)k\n\x0f\n\x08\x04\x03\x02\0\x08\xd0\x86\x03\x12\x03#*j\n\x0b\n\
    \x04\x04\x03\x02\x01\x12\x03$\x08n\n\x0c\n\x05\x04\x03\x02\x01\x04\x12\
    \x03$\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03$\x11\x18\n\x0c\n\
    \x05\x04\x03\x02\x01\x01\x12\x03$\x19&\n\x0c\n\x05\x04\x03\x02\x01\x03\
    \x12\x03$)*\n\x0c\n\x05\x04\x03\x02\x01\x08\x12\x03$+m\n\x0f\n\x08\x04\
    \x03\x02\x01\x08\xd0\x86\x03\x12\x03$,l\n\x0b\n\x04\x04\x03\x02\x02\x12\
    \x03%\x08b\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03%\x08\x10\n\x0c\n\x05\
    \x04\x03\x02\x02\x05\x12\x03%\x11\x17\n\x0c\n\x05\x04\x03\x02\x02\x01\
    \x12\x03%\x18'\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03%*+\n\x0c\n\x05\
    \x04\x03\x02\x02\x08\x12\x03%,a\n\x0f\n\x08\x04\x03\x02\x02\x08\xd0\x86\
    \x03\x12\x03%-`\n\x0b\n\x04\x04\x03\x02\x03\x12\x03&\x08O\n\x0c\n\x05\
    \x04\x03\x02\x03\x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x03\x02\x03\x05\
    \x12\x03&\x11\x17\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03&\x18\x1b\n\x0c\
    \n\x05\x04\x03\x02\x03\x03\x12\x03&\x1e\x1f\n\x0c\n\x05\x04\x03\x02\x03\
    \x08\x12\x03&\x20N\n\x0f\n\x08\x04\x03\x02\x03\x08\xd0\x86\x03\x12\x03&!\
    M\n\x0b\n\x04\x04\x03\x02\x04\x12\x03'\x08P\n\x0c\n\x05\x04\x03\x02\x04\
    \x04\x12\x03'\x08\x10\n\x0c\n\x05\x04\x03\x02\x04\x05\x12\x03'\x11\x17\n\
    \x0c\n\x05\x04\x03\x02\x04\x01\x12\x03'\x18#\n\x0c\n\x05\x04\x03\x02\x04\
    \x03\x12\x03'&'\n\x0c\n\x05\x04\x03\x02\x04\x08\x12\x03'(O\n\x0f\n\x08\
    \x04\x03\x02\x04\x08\xd0\x86\x03\x12\x03')N\n\x0b\n\x04\x04\x03\x02\x05\
    \x12\x03(\x08e\n\x0c\n\x05\x04\x03\x02\x05\x04\x12\x03(\x08\x10\n\x0c\n\
    \x05\x04\x03\x02\x05\x05\x12\x03(\x11\x17\n\x0c\n\x05\x04\x03\x02\x05\
    \x01\x12\x03(\x18$\n\x0c\n\x05\x04\x03\x02\x05\x03\x12\x03('(\n\x0c\n\
    \x05\x04\x03\x02\x05\x08\x12\x03()d\n\x0f\n\x08\x04\x03\x02\x05\x08\xd0\
    \x86\x03\x12\x03(*c\n\x0b\n\x04\x04\x03\x02\x06\x12\x03)\x08W\n\x0c\n\
    \x05\x04\x03\x02\x06\x04\x12\x03)\x08\x10\n\x0c\n\x05\x04\x03\x02\x06\
    \x05\x12\x03)\x11\x17\n\x0c\n\x05\x04\x03\x02\x06\x01\x12\x03)\x18!\n\
    \x0c\n\x05\x04\x03\x02\x06\x03\x12\x03)$%\n\x0c\n\x05\x04\x03\x02\x06\
    \x08\x12\x03)&V\n\x0f\n\x08\x04\x03\x02\x06\x08\xd0\x86\x03\x12\x03)'U\n\
    \x0b\n\x04\x04\x03\x02\x07\x12\x03*\x08y\n\x0c\n\x05\x04\x03\x02\x07\x04\
    \x12\x03*\x08\x10\n\x0c\n\x05\x04\x03\x02\x07\x05\x12\x03*\x11\x16\n\x0c\
    \n\x05\x04\x03\x02\x07\x01\x12\x03*\x17&\n\x0c\n\x05\x04\x03\x02\x07\x03\
    \x12\x03*)*\n\x0c\n\x05\x04\x03\x02\x07\x08\x12\x03*+x\n\x0f\n\x08\x04\
    \x03\x02\x07\x08\xd0\x86\x03\x12\x03*,w\n\x0b\n\x04\x04\x03\x02\x08\x12\
    \x03+\x08L\n\x0c\n\x05\x04\x03\x02\x08\x04\x12\x03+\x08\x10\n\x0c\n\x05\
    \x04\x03\x02\x08\x05\x12\x03+\x11\x16\n\x0c\n\x05\x04\x03\x02\x08\x01\
    \x12\x03+\x17\x1f\n\x0c\n\x05\x04\x03\x02\x08\x03\x12\x03+\"#\n\x0c\n\
    \x05\x04\x03\x02\x08\x08\x12\x03+$K\n\x0f\n\x08\x04\x03\x02\x08\x08\xd0\
    \x86\x03\x12\x03+%J\n\x0b\n\x04\x04\x03\x02\t\x12\x03,\x08C\n\x0c\n\x05\
    \x04\x03\x02\t\x04\x12\x03,\x08\x10\n\x0c\n\x05\x04\x03\x02\t\x05\x12\
    \x03,\x11\x16\n\x0c\n\x05\x04\x03\x02\t\x01\x12\x03,\x17\x1d\n\x0c\n\x05\
    \x04\x03\x02\t\x03\x12\x03,\x20\"\n\x0c\n\x05\x04\x03\x02\t\x08\x12\x03,\
    #B\n\x0f\n\x08\x04\x03\x02\t\x08\xd0\x86\x03\x12\x03,$A\n\n\n\x02\x04\
    \x04\x12\x04/\03\x01\n\n\n\x03\x04\x04\x01\x12\x03/\x08$\n\x0b\n\x04\x04\
    \x04\x02\0\x12\x030\x08H\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x030\x08\x10\
    \n\x0c\n\x05\x04\x04\x02\0\x05\x12\x030\x11\x18\n\x0c\n\x05\x04\x04\x02\
    \0\x01\x12\x030\x19\x20\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x030#$\n\x0c\n\
    \x05\x04\x04\x02\0\x08\x12\x030%G\n\x0f\n\x08\x04\x04\x02\0\x08\xd0\x86\
    \x03\x12\x030&F\n\x0b\n\x04\x04\x04\x02\x01\x12\x031\x08j\n\x0c\n\x05\
    \x04\x04\x02\x01\x04\x12\x031\x08\x10\n\x0c\n\x05\x04\x04\x02\x01\x05\
    \x12\x031\x11\x17\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x031\x18\"\n\x0c\n\
    \x05\x04\x04\x02\x01\x03\x12\x031%&\n\x0c\n\x05\x04\x04\x02\x01\x08\x12\
    \x031'i\n\x0f\n\x08\x04\x04\x02\x01\x08\xd0\x86\x03\x12\x031(h\n\x0b\n\
    \x04\x04\x04\x02\x02\x12\x032\x08r\n\x0c\n\x05\x04\x04\x02\x02\x04\x12\
    \x032\x08\x10\n\x0c\n\x05\x04\x04\x02\x02\x05\x12\x032\x11\x15\n\x0c\n\
    \x05\x04\x04\x02\x02\x01\x12\x032\x16-\n\x0c\n\x05\x04\x04\x02\x02\x03\
    \x12\x03201\n\x0c\n\x05\x04\x04\x02\x02\x08\x12\x0322q\n\x0f\n\x08\x04\
    \x04\x02\x02\x08\xd0\x86\x03\x12\x0323p\n\n\n\x02\x04\x05\x12\x045\06\
    \x01\n\n\n\x03\x04\x05\x01\x12\x035\x08%\n\n\n\x02\x04\x06\x12\x048\0>\
    \x01\n\n\n\x03\x04\x06\x01\x12\x038\x083\n\x0b\n\x04\x04\x06\x02\0\x12\
    \x039\x08H\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x039\x08\x10\n\x0c\n\x05\
    \x04\x06\x02\0\x05\x12\x039\x11\x18\n\x0c\n\x05\x04\x06\x02\0\x01\x12\
    \x039\x19\x20\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x039#$\n\x0c\n\x05\x04\
    \x06\x02\0\x08\x12\x039%G\n\x0f\n\x08\x04\x06\x02\0\x08\xd0\x86\x03\x12\
    \x039&F\n\x0b\n\x04\x04\x06\x02\x01\x12\x03:\x08U\n\x0c\n\x05\x04\x06\
    \x02\x01\x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03:\
    \x11\x17\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03:\x18*\n\x0c\n\x05\x04\
    \x06\x02\x01\x03\x12\x03:-.\n\x0c\n\x05\x04\x06\x02\x01\x08\x12\x03:/T\n\
    \x0f\n\x08\x04\x06\x02\x01\x08\xd0\x86\x03\x12\x03:0S\n\x0b\n\x04\x04\
    \x06\x02\x02\x12\x03;\x08^\n\x0c\n\x05\x04\x06\x02\x02\x04\x12\x03;\x08\
    \x10\n\x0c\n\x05\x04\x06\x02\x02\x05\x12\x03;\x11\x17\n\x0c\n\x05\x04\
    \x06\x02\x02\x01\x12\x03;\x18*\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\x03;-\
    .\n\x0c\n\x05\x04\x06\x02\x02\x08\x12\x03;/]\n\x0f\n\x08\x04\x06\x02\x02\
    \x08\xd0\x86\x03\x12\x03;0\\\n\x0b\n\x04\x04\x06\x02\x03\x12\x03<\x08i\n\
    \x0c\n\x05\x04\x06\x02\x03\x04\x12\x03<\x08\x10\n\x0c\n\x05\x04\x06\x02\
    \x03\x05\x12\x03<\x11\x17\n\x0c\n\x05\x04\x06\x02\x03\x01\x12\x03<\x18'\
    \n\x0c\n\x05\x04\x06\x02\x03\x03\x12\x03<*+\n\x0c\n\x05\x04\x06\x02\x03\
    \x08\x12\x03<,h\n\x0f\n\x08\x04\x06\x02\x03\x08\xd0\x86\x03\x12\x03<-g\n\
    \x0b\n\x04\x04\x06\x02\x04\x12\x03=\x08]\n\x0c\n\x05\x04\x06\x02\x04\x04\
    \x12\x03=\x08\x10\n\x0c\n\x05\x04\x06\x02\x04\x05\x12\x03=\x11\x17\n\x0c\
    \n\x05\x04\x06\x02\x04\x01\x12\x03=\x18$\n\x0c\n\x05\x04\x06\x02\x04\x03\
    \x12\x03='(\n\x0c\n\x05\x04\x06\x02\x04\x08\x12\x03=)\\\n\x0f\n\x08\x04\
    \x06\x02\x04\x08\xd0\x86\x03\x12\x03=*[\n\n\n\x02\x04\x07\x12\x04@\0E\
    \x01\n\n\n\x03\x04\x07\x01\x12\x03@\x084\n\x0b\n\x04\x04\x07\x02\0\x12\
    \x03A\x08\\\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03A\x08\x10\n\x0c\n\x05\
    \x04\x07\x02\0\x05\x12\x03A\x11\x15\n\x0c\n\x05\x04\x07\x02\0\x01\x12\
    \x03A\x16\x1d\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03A\x20!\n\x0c\n\x05\
    \x04\x07\x02\0\x08\x12\x03A\"[\n\x0f\n\x08\x04\x07\x02\0\x08\xd0\x86\x03\
    \x12\x03A#Z\n\x0b\n\x04\x04\x07\x02\x01\x12\x03B\x08P\n\x0c\n\x05\x04\
    \x07\x02\x01\x04\x12\x03B\x08\x10\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\
    \x03B\x11\x15\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03B\x16\x1f\n\x0c\n\
    \x05\x04\x07\x02\x01\x03\x12\x03B\"#\n\x0c\n\x05\x04\x07\x02\x01\x08\x12\
    \x03B$O\n\x0f\n\x08\x04\x07\x02\x01\x08\xd0\x86\x03\x12\x03B%N\n\x0b\n\
    \x04\x04\x07\x02\x02\x12\x03C\x08P\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\
    \x03C\x08\x10\n\x0c\n\x05\x04\x07\x02\x02\x05\x12\x03C\x11\x17\n\x0c\n\
    \x05\x04\x07\x02\x02\x01\x12\x03C\x18#\n\x0c\n\x05\x04\x07\x02\x02\x03\
    \x12\x03C&'\n\x0c\n\x05\x04\x07\x02\x02\x08\x12\x03C(O\n\x0f\n\x08\x04\
    \x07\x02\x02\x08\xd0\x86\x03\x12\x03C)N\n\x0b\n\x04\x04\x07\x02\x03\x12\
    \x03D\x08B\n\x0c\n\x05\x04\x07\x02\x03\x04\x12\x03D\x08\x10\n\x0c\n\x05\
    \x04\x07\x02\x03\x05\x12\x03D\x11\x16\n\x0c\n\x05\x04\x07\x02\x03\x01\
    \x12\x03D\x17\x1d\n\x0c\n\x05\x04\x07\x02\x03\x03\x12\x03D\x20!\n\x0c\n\
    \x05\x04\x07\x02\x03\x08\x12\x03D\"A\n\x0f\n\x08\x04\x07\x02\x03\x08\xd0\
    \x86\x03\x12\x03D#@\n\n\n\x02\x04\x08\x12\x04G\0L\x01\n\n\n\x03\x04\x08\
    \x01\x12\x03G\x08.\n\x0b\n\x04\x04\x08\x02\0\x12\x03H\x08`\n\x0c\n\x05\
    \x04\x08\x02\0\x04\x12\x03H\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\
    \x03H\x11\x17\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03H\x18'\n\x0c\n\x05\
    \x04\x08\x02\0\x03\x12\x03H*+\n\x0c\n\x05\x04\x08\x02\0\x08\x12\x03H,_\n\
    \x0f\n\x08\x04\x08\x02\0\x08\xd0\x86\x03\x12\x03H-^\n\x0b\n\x04\x04\x08\
    \x02\x01\x12\x03I\x08l\n\x0c\n\x05\x04\x08\x02\x01\x04\x12\x03I\x08\x10\
    \n\x0c\n\x05\x04\x08\x02\x01\x05\x12\x03I\x11\x17\n\x0c\n\x05\x04\x08\
    \x02\x01\x01\x12\x03I\x18)\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x03I,-\n\
    \x0c\n\x05\x04\x08\x02\x01\x08\x12\x03I.k\n\x0f\n\x08\x04\x08\x02\x01\
    \x08\xd0\x86\x03\x12\x03I/j\n\x0b\n\x04\x04\x08\x02\x02\x12\x03J\x08s\n\
    \x0c\n\x05\x04\x08\x02\x02\x04\x12\x03J\x08\x10\n\x0c\n\x05\x04\x08\x02\
    \x02\x05\x12\x03J\x11\x17\n\x0c\n\x05\x04\x08\x02\x02\x01\x12\x03J\x18)\
    \n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x03J,-\n\x0c\n\x05\x04\x08\x02\x02\
    \x08\x12\x03J.r\n\x0f\n\x08\x04\x08\x02\x02\x08\xd0\x86\x03\x12\x03J/q\n\
    \x0b\n\x04\x04\x08\x02\x03\x12\x03K\x08j\n\x0c\n\x05\x04\x08\x02\x03\x04\
    \x12\x03K\x08\x10\n\x0c\n\x05\x04\x08\x02\x03\x05\x12\x03K\x11\x15\n\x0c\
    \n\x05\x04\x08\x02\x03\x01\x12\x03K\x163\n\x0c\n\x05\x04\x08\x02\x03\x03\
    \x12\x03K67\n\x0c\n\x05\x04\x08\x02\x03\x08\x12\x03K8i\n\x0f\n\x08\x04\
    \x08\x02\x03\x08\xd0\x86\x03\x12\x03K9h\n\n\n\x02\x04\t\x12\x04N\0R\x01\
    \n\n\n\x03\x04\t\x01\x12\x03N\x08/\n\x0b\n\x04\x04\t\x02\0\x12\x03O\x08n\
    \n\x0c\n\x05\x04\t\x02\0\x04\x12\x03O\x08\x10\n\x0c\n\x05\x04\t\x02\0\
    \x05\x12\x03O\x11\x15\n\x0c\n\x05\x04\t\x02\0\x01\x12\x03O\x16\x1d\n\x0c\
    \n\x05\x04\t\x02\0\x03\x12\x03O\x20!\n\x0c\n\x05\x04\t\x02\0\x08\x12\x03\
    O\"m\n\x0f\n\x08\x04\t\x02\0\x08\xd0\x86\x03\x12\x03O#l\n\x0b\n\x04\x04\
    \t\x02\x01\x12\x03P\x08P\n\x0c\n\x05\x04\t\x02\x01\x04\x12\x03P\x08\x10\
    \n\x0c\n\x05\x04\t\x02\x01\x05\x12\x03P\x11\x17\n\x0c\n\x05\x04\t\x02\
    \x01\x01\x12\x03P\x18#\n\x0c\n\x05\x04\t\x02\x01\x03\x12\x03P&'\n\x0c\n\
    \x05\x04\t\x02\x01\x08\x12\x03P(O\n\x0f\n\x08\x04\t\x02\x01\x08\xd0\x86\
    \x03\x12\x03P)N\n\x0b\n\x04\x04\t\x02\x02\x12\x03Q\x08{\n\x0c\n\x05\x04\
    \t\x02\x02\x04\x12\x03Q\x08\x10\n\x0c\n\x05\x04\t\x02\x02\x05\x12\x03Q\
    \x11\x17\n\x0c\n\x05\x04\t\x02\x02\x01\x12\x03Q\x185\n\x0c\n\x05\x04\t\
    \x02\x02\x03\x12\x03Q89\n\x0c\n\x05\x04\t\x02\x02\x08\x12\x03Q:z\n\x0f\n\
    \x08\x04\t\x02\x02\x08\xd0\x86\x03\x12\x03Q;y\n\n\n\x02\x04\n\x12\x04T\0\
    V\x01\n\n\n\x03\x04\n\x01\x12\x03T\x08/\n\x0b\n\x04\x04\n\x02\0\x12\x03U\
    \x08!\n\x0c\n\x05\x04\n\x02\0\x04\x12\x03U\x08\x10\n\x0c\n\x05\x04\n\x02\
    \0\x05\x12\x03U\x11\x17\n\x0c\n\x05\x04\n\x02\0\x01\x12\x03U\x18\x1c\n\
    \x0c\n\x05\x04\n\x02\0\x03\x12\x03U\x1f\x20\n\n\n\x02\x04\x0b\x12\x04X\0\
    Z\x01\n\n\n\x03\x04\x0b\x01\x12\x03X\x080\n\x0b\n\x04\x04\x0b\x02\0\x12\
    \x03Y\x08F\n\x0c\n\x05\x04\x0b\x02\0\x04\x12\x03Y\x08\x10\n\x0c\n\x05\
    \x04\x0b\x02\0\x05\x12\x03Y\x11\x17\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\
    \x03Y\x18\x1d\n\x0c\n\x05\x04\x0b\x02\0\x03\x12\x03Y\x20!\n\x0c\n\x05\
    \x04\x0b\x02\0\x08\x12\x03Y\"E\n\x0f\n\x08\x04\x0b\x02\0\x08\xd0\x86\x03\
    \x12\x03Y#D\n\n\n\x02\x04\x0c\x12\x04\\\0^\x01\n\n\n\x03\x04\x0c\x01\x12\
    \x03\\\x080\n\x0b\n\x04\x04\x0c\x02\0\x12\x03]\x08H\n\x0c\n\x05\x04\x0c\
    \x02\0\x04\x12\x03]\x08\x10\n\x0c\n\x05\x04\x0c\x02\0\x05\x12\x03]\x11\
    \x18\n\x0c\n\x05\x04\x0c\x02\0\x01\x12\x03]\x19\x20\n\x0c\n\x05\x04\x0c\
    \x02\0\x03\x12\x03]#$\n\x0c\n\x05\x04\x0c\x02\0\x08\x12\x03]%G\n\x0f\n\
    \x08\x04\x0c\x02\0\x08\xd0\x86\x03\x12\x03]&F\n\n\n\x02\x04\r\x12\x04`\0\
    a\x01\n\n\n\x03\x04\r\x01\x12\x03`\x081\n\n\n\x02\x04\x0e\x12\x04c\0e\
    \x01\n\n\n\x03\x04\x0e\x01\x12\x03c\x08(\n\x0b\n\x04\x04\x0e\x02\0\x12\
    \x03d\x08F\n\x0c\n\x05\x04\x0e\x02\0\x04\x12\x03d\x08\x10\n\x0c\n\x05\
    \x04\x0e\x02\0\x05\x12\x03d\x11\x17\n\x0c\n\x05\x04\x0e\x02\0\x01\x12\
    \x03d\x18\x1c\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\x03d\x1f\x20\n\x0c\n\x05\
    \x04\x0e\x02\0\x08\x12\x03d!E\n\x0f\n\x08\x04\x0e\x02\0\x08\xd0\x86\x03\
    \x12\x03d\"D\n\n\n\x02\x04\x0f\x12\x04g\0i\x01\n\n\n\x03\x04\x0f\x01\x12\
    \x03g\x08)\n\x0b\n\x04\x04\x0f\x02\0\x12\x03h\x08I\n\x0c\n\x05\x04\x0f\
    \x02\0\x04\x12\x03h\x08\x10\n\x0c\n\x05\x04\x0f\x02\0\x05\x12\x03h\x11\
    \x15\n\x0c\n\x05\x04\x0f\x02\0\x01\x12\x03h\x16\x1b\n\x0c\n\x05\x04\x0f\
    \x02\0\x03\x12\x03h\x1e\x1f\n\x0c\n\x05\x04\x0f\x02\0\x08\x12\x03h\x20H\
    \n\x0f\n\x08\x04\x0f\x02\0\x08\xd0\x86\x03\x12\x03h!G\n\x0b\n\x02\x06\0\
    \x12\x05k\0\x8d\x01\x01\n\n\n\x03\x06\0\x01\x12\x03k\x08\x11\n\n\n\x03\
    \x06\0\x03\x12\x03l\x08K\n\r\n\x06\x06\0\x03\xd0\x86\x03\x12\x03l\x08K\n\
    \x0c\n\x04\x06\0\x02\0\x12\x04n\x08p\t\n\x0c\n\x05\x06\0\x02\0\x01\x12\
    \x03n\x0c\x17\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03n\x193\n\x0c\n\x05\x06\
    \0\x02\0\x03\x12\x03n>Y\n\x0c\n\x05\x06\0\x02\0\x04\x12\x03o\x10q\n\x0f\
    \n\x08\x06\0\x02\0\x04\xd0\x86\x03\x12\x03o\x10q\n\x0c\n\x04\x06\0\x02\
    \x01\x12\x04r\x08t\t\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03r\x0c\x1c\n\
    \x0c\n\x05\x06\0\x02\x01\x02\x12\x03r\x1eB\n\x0c\n\x05\x06\0\x02\x01\x03\
    \x12\x03rMr\n\x0c\n\x05\x06\0\x02\x01\x04\x12\x03s\x10f\n\x0f\n\x08\x06\
    \0\x02\x01\x04\xd0\x86\x03\x12\x03s\x10f\n\x0c\n\x04\x06\0\x02\x02\x12\
    \x04v\x08x\t\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03v\x0c\x15\n\x0c\n\x05\
    \x06\0\x02\x02\x02\x12\x03v\x174\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03v?\
    ]\n\x0c\n\x05\x06\0\x02\x02\x04\x12\x03w\x10J\n\x0f\n\x08\x06\0\x02\x02\
    \x04\xd0\x86\x03\x12\x03w\x10J\n\x0c\n\x04\x06\0\x02\x03\x12\x04z\x08|\t\
    \n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03z\x0c$\n\x0c\n\x05\x06\0\x02\x03\
    \x02\x12\x03z&R\n\r\n\x05\x06\0\x02\x03\x03\x12\x04z]\x8a\x01\n\x0c\n\
    \x05\x06\0\x02\x03\x04\x12\x03{\x10u\n\x0f\n\x08\x06\0\x02\x03\x04\xd0\
    \x86\x03\x12\x03{\x10u\n\r\n\x04\x06\0\x02\x04\x12\x05~\x08\x80\x01\t\n\
    \x0c\n\x05\x06\0\x02\x04\x01\x12\x03~\x0c\x1f\n\x0c\n\x05\x06\0\x02\x04\
    \x02\x12\x03~!H\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03~S{\n\x0c\n\x05\x06\
    \0\x02\x04\x04\x12\x03\x7f\x10u\n\x0f\n\x08\x06\0\x02\x04\x04\xd0\x86\
    \x03\x12\x03\x7f\x10u\n\x0e\n\x04\x06\0\x02\x05\x12\x06\x82\x01\x08\x84\
    \x01\t\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\x82\x01\x0c\x20\n\r\n\x05\x06\
    \0\x02\x05\x02\x12\x04\x82\x01\"J\n\r\n\x05\x06\0\x02\x05\x03\x12\x04\
    \x82\x01U~\n\r\n\x05\x06\0\x02\x05\x04\x12\x04\x83\x01\x10W\n\x10\n\x08\
    \x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\x83\x01\x10W\n\x0e\n\x04\x06\0\
    \x02\x06\x12\x06\x86\x01\x08\x88\x01\t\n\r\n\x05\x06\0\x02\x06\x01\x12\
    \x04\x86\x01\x0c!\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\x86\x01#L\n\x0e\n\
    \x05\x06\0\x02\x06\x03\x12\x05\x86\x01W\x81\x01\n\r\n\x05\x06\0\x02\x06\
    \x04\x12\x04\x87\x01\x10f\n\x10\n\x08\x06\0\x02\x06\x04\xd0\x86\x03\x12\
    \x04\x87\x01\x10f\n\x0e\n\x04\x06\0\x02\x07\x12\x06\x8a\x01\x08\x8c\x01\
    \t\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\x8a\x01\x0c\x19\n\r\n\x05\x06\0\
    \x02\x07\x02\x12\x04\x8a\x01\x1b<\n\r\n\x05\x06\0\x02\x07\x03\x12\x04\
    \x8a\x01Gi\n\r\n\x05\x06\0\x02\x07\x04\x12\x04\x8b\x01\x10O\n\x10\n\x08\
    \x06\0\x02\x07\x04\xd0\x86\x03\x12\x04\x8b\x01\x10O\
";

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