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_inventory.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 CInventory_GetInventory_Request {
    // message fields
    appid: ::std::option::Option<u32>,
    steamid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 steamid = 2;


    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 CInventory_GetInventory_Request {
    fn is_initialized(&self) -> bool {
        true
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CInventory_Response {
    // message fields
    etag: ::protobuf::SingularField<::std::string::String>,
    pub removeditemids: ::std::vec::Vec<u64>,
    item_json: ::protobuf::SingularField<::std::string::String>,
    itemdef_json: ::protobuf::SingularField<::std::string::String>,
    ticket: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    replayed: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string etag = 1;


    pub fn get_etag(&self) -> &str {
        match self.etag.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_etag(&mut self) {
        self.etag.clear();
    }

    pub fn has_etag(&self) -> bool {
        self.etag.is_some()
    }

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

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

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

    // repeated uint64 removeditemids = 2;


    pub fn get_removeditemids(&self) -> &[u64] {
        &self.removeditemids
    }
    pub fn clear_removeditemids(&mut self) {
        self.removeditemids.clear();
    }

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

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

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

    // optional string item_json = 3;


    pub fn get_item_json(&self) -> &str {
        match self.item_json.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_item_json(&mut self) {
        self.item_json.clear();
    }

    pub fn has_item_json(&self) -> bool {
        self.item_json.is_some()
    }

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

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

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

    // optional string itemdef_json = 4;


    pub fn get_itemdef_json(&self) -> &str {
        match self.itemdef_json.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_itemdef_json(&mut self) {
        self.itemdef_json.clear();
    }

    pub fn has_itemdef_json(&self) -> bool {
        self.itemdef_json.is_some()
    }

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

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

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

    // optional bytes ticket = 5;


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

    pub fn has_ticket(&self) -> bool {
        self.ticket.is_some()
    }

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

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

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

    // optional bool replayed = 6;


    pub fn get_replayed(&self) -> bool {
        self.replayed.unwrap_or(false)
    }
    pub fn clear_replayed(&mut self) {
        self.replayed = ::std::option::Option::None;
    }

    pub fn has_replayed(&self) -> bool {
        self.replayed.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.etag)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.removeditemids)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.item_json)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.itemdef_json)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.ticket)?;
                },
                6 => {
                    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.replayed = ::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.etag.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        for value in &self.removeditemids {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(ref v) = self.item_json.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.itemdef_json.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(ref v) = self.ticket.as_ref() {
            my_size += ::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(v) = self.replayed {
            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.etag.as_ref() {
            os.write_string(1, &v)?;
        }
        for v in &self.removeditemids {
            os.write_uint64(2, *v)?;
        };
        if let Some(ref v) = self.item_json.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.itemdef_json.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(ref v) = self.ticket.as_ref() {
            os.write_bytes(5, &v)?;
        }
        if let Some(v) = self.replayed {
            os.write_bool(6, 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() -> CInventory_Response {
        CInventory_Response::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "etag",
                |m: &CInventory_Response| { &m.etag },
                |m: &mut CInventory_Response| { &mut m.etag },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "removeditemids",
                |m: &CInventory_Response| { &m.removeditemids },
                |m: &mut CInventory_Response| { &mut m.removeditemids },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "item_json",
                |m: &CInventory_Response| { &m.item_json },
                |m: &mut CInventory_Response| { &mut m.item_json },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "itemdef_json",
                |m: &CInventory_Response| { &m.itemdef_json },
                |m: &mut CInventory_Response| { &mut m.itemdef_json },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "ticket",
                |m: &CInventory_Response| { &m.ticket },
                |m: &mut CInventory_Response| { &mut m.ticket },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "replayed",
                |m: &CInventory_Response| { &m.replayed },
                |m: &mut CInventory_Response| { &mut m.replayed },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_Response>(
                "CInventory_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_Response {
    fn clear(&mut self) {
        self.etag.clear();
        self.removeditemids.clear();
        self.item_json.clear();
        self.itemdef_json.clear();
        self.ticket.clear();
        self.replayed = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 steamid = 2;


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

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

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

    // repeated uint64 materialsitemid = 3;


    pub fn get_materialsitemid(&self) -> &[u64] {
        &self.materialsitemid
    }
    pub fn clear_materialsitemid(&mut self) {
        self.materialsitemid.clear();
    }

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

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

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

    // repeated uint32 materialsquantity = 4;


    pub fn get_materialsquantity(&self) -> &[u32] {
        &self.materialsquantity
    }
    pub fn clear_materialsquantity(&mut self) {
        self.materialsquantity.clear();
    }

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

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

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

    // optional uint64 outputitemdefid = 5;


    pub fn get_outputitemdefid(&self) -> u64 {
        self.outputitemdefid.unwrap_or(0)
    }
    pub fn clear_outputitemdefid(&mut self) {
        self.outputitemdefid = ::std::option::Option::None;
    }

    pub fn has_outputitemdefid(&self) -> bool {
        self.outputitemdefid.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.materialsitemid)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_uint32_into(wire_type, is, &mut self.materialsquantity)?;
                },
                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.outputitemdefid = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.materialsitemid {
            my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in &self.materialsquantity {
            my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(v) = self.outputitemdefid {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(2, v)?;
        }
        for v in &self.materialsitemid {
            os.write_uint64(3, *v)?;
        };
        for v in &self.materialsquantity {
            os.write_uint32(4, *v)?;
        };
        if let Some(v) = self.outputitemdefid {
            os.write_uint64(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() -> CInventory_ExchangeItem_Request {
        CInventory_ExchangeItem_Request::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CInventory_ExchangeItem_Request| { &m.appid },
                |m: &mut CInventory_ExchangeItem_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "steamid",
                |m: &CInventory_ExchangeItem_Request| { &m.steamid },
                |m: &mut CInventory_ExchangeItem_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "materialsitemid",
                |m: &CInventory_ExchangeItem_Request| { &m.materialsitemid },
                |m: &mut CInventory_ExchangeItem_Request| { &mut m.materialsitemid },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "materialsquantity",
                |m: &CInventory_ExchangeItem_Request| { &m.materialsquantity },
                |m: &mut CInventory_ExchangeItem_Request| { &mut m.materialsquantity },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "outputitemdefid",
                |m: &CInventory_ExchangeItem_Request| { &m.outputitemdefid },
                |m: &mut CInventory_ExchangeItem_Request| { &mut m.outputitemdefid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_ExchangeItem_Request>(
                "CInventory_ExchangeItem_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_ExchangeItem_Request {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.materialsitemid.clear();
        self.materialsquantity.clear();
        self.outputitemdefid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 steamid = 2;


    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 CInventory_GetEligiblePromoItemDefIDs_Request {
    fn is_initialized(&self) -> bool {
        true
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // repeated uint64 itemdefids = 1;


    pub fn get_itemdefids(&self) -> &[u64] {
        &self.itemdefids
    }
    pub fn clear_itemdefids(&mut self) {
        self.itemdefids.clear();
    }

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

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

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

impl ::protobuf::Message for CInventory_GetEligiblePromoItemDefIDs_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_uint64_into(wire_type, is, &mut self.itemdefids)?;
                },
                _ => {
                    ::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.itemdefids {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.itemdefids {
            os.write_uint64(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() -> CInventory_GetEligiblePromoItemDefIDs_Response {
        CInventory_GetEligiblePromoItemDefIDs_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_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "itemdefids",
                |m: &CInventory_GetEligiblePromoItemDefIDs_Response| { &m.itemdefids },
                |m: &mut CInventory_GetEligiblePromoItemDefIDs_Response| { &mut m.itemdefids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_GetEligiblePromoItemDefIDs_Response>(
                "CInventory_GetEligiblePromoItemDefIDs_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CInventory_AddItem_Request {
    // message fields
    appid: ::std::option::Option<u32>,
    pub itemdefid: ::std::vec::Vec<u64>,
    pub itempropsjson: ::protobuf::RepeatedField<::std::string::String>,
    steamid: ::std::option::Option<u64>,
    notify: ::std::option::Option<bool>,
    requestid: ::std::option::Option<u64>,
    trade_restriction: ::std::option::Option<bool>,
    is_purchase: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


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

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

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

    // repeated uint64 itemdefid = 2;


    pub fn get_itemdefid(&self) -> &[u64] {
        &self.itemdefid
    }
    pub fn clear_itemdefid(&mut self) {
        self.itemdefid.clear();
    }

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

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

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

    // repeated string itempropsjson = 3;


    pub fn get_itempropsjson(&self) -> &[::std::string::String] {
        &self.itempropsjson
    }
    pub fn clear_itempropsjson(&mut self) {
        self.itempropsjson.clear();
    }

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

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

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

    // optional uint64 steamid = 4;


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

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

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

    // optional bool notify = 5;


    pub fn get_notify(&self) -> bool {
        self.notify.unwrap_or(false)
    }
    pub fn clear_notify(&mut self) {
        self.notify = ::std::option::Option::None;
    }

    pub fn has_notify(&self) -> bool {
        self.notify.is_some()
    }

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

    // optional uint64 requestid = 6;


    pub fn get_requestid(&self) -> u64 {
        self.requestid.unwrap_or(0)
    }
    pub fn clear_requestid(&mut self) {
        self.requestid = ::std::option::Option::None;
    }

    pub fn has_requestid(&self) -> bool {
        self.requestid.is_some()
    }

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

    // optional bool trade_restriction = 7;


    pub fn get_trade_restriction(&self) -> bool {
        self.trade_restriction.unwrap_or(false)
    }
    pub fn clear_trade_restriction(&mut self) {
        self.trade_restriction = ::std::option::Option::None;
    }

    pub fn has_trade_restriction(&self) -> bool {
        self.trade_restriction.is_some()
    }

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

    // optional bool is_purchase = 8;


    pub fn get_is_purchase(&self) -> bool {
        self.is_purchase.unwrap_or(false)
    }
    pub fn clear_is_purchase(&mut self) {
        self.is_purchase = ::std::option::Option::None;
    }

    pub fn has_is_purchase(&self) -> bool {
        self.is_purchase.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.itemdefid)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.itempropsjson)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.notify = ::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_uint64()?;
                    self.requestid = ::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.trade_restriction = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_purchase = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.itemdefid {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in &self.itempropsjson {
            my_size += ::protobuf::rt::string_size(3, &value);
        };
        if let Some(v) = self.steamid {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.notify {
            my_size += 2;
        }
        if let Some(v) = self.requestid {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.trade_restriction {
            my_size += 2;
        }
        if let Some(v) = self.is_purchase {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        for v in &self.itemdefid {
            os.write_uint64(2, *v)?;
        };
        for v in &self.itempropsjson {
            os.write_string(3, &v)?;
        };
        if let Some(v) = self.steamid {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.notify {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.requestid {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.trade_restriction {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.is_purchase {
            os.write_bool(8, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CInventory_AddItem_Request| { &m.appid },
                |m: &mut CInventory_AddItem_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "itemdefid",
                |m: &CInventory_AddItem_Request| { &m.itemdefid },
                |m: &mut CInventory_AddItem_Request| { &mut m.itemdefid },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "itempropsjson",
                |m: &CInventory_AddItem_Request| { &m.itempropsjson },
                |m: &mut CInventory_AddItem_Request| { &mut m.itempropsjson },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "steamid",
                |m: &CInventory_AddItem_Request| { &m.steamid },
                |m: &mut CInventory_AddItem_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "notify",
                |m: &CInventory_AddItem_Request| { &m.notify },
                |m: &mut CInventory_AddItem_Request| { &mut m.notify },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "requestid",
                |m: &CInventory_AddItem_Request| { &m.requestid },
                |m: &mut CInventory_AddItem_Request| { &mut m.requestid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "trade_restriction",
                |m: &CInventory_AddItem_Request| { &m.trade_restriction },
                |m: &mut CInventory_AddItem_Request| { &mut m.trade_restriction },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_purchase",
                |m: &CInventory_AddItem_Request| { &m.is_purchase },
                |m: &mut CInventory_AddItem_Request| { &mut m.is_purchase },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_AddItem_Request>(
                "CInventory_AddItem_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_AddItem_Request {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.itemdefid.clear();
        self.itempropsjson.clear();
        self.steamid = ::std::option::Option::None;
        self.notify = ::std::option::Option::None;
        self.requestid = ::std::option::Option::None;
        self.trade_restriction = ::std::option::Option::None;
        self.is_purchase = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 steamid = 2;


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

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

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

    // repeated .CInventory_ModifyItems_Request.ItemPropertyUpdate updates = 3;


    pub fn get_updates(&self) -> &[CInventory_ModifyItems_Request_ItemPropertyUpdate] {
        &self.updates
    }
    pub fn clear_updates(&mut self) {
        self.updates.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_updates(&mut self) -> &mut ::protobuf::RepeatedField<CInventory_ModifyItems_Request_ItemPropertyUpdate> {
        &mut self.updates
    }

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

    // optional uint32 timestamp = 4;


    pub fn get_timestamp(&self) -> u32 {
        self.timestamp.unwrap_or(0)
    }
    pub fn clear_timestamp(&mut self) {
        self.timestamp = ::std::option::Option::None;
    }

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.steamid = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.updates)?;
                },
                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.timestamp = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.updates {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.timestamp {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(2, v)?;
        }
        for v in &self.updates {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.timestamp {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CInventory_ModifyItems_Request| { &m.appid },
                |m: &mut CInventory_ModifyItems_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "steamid",
                |m: &CInventory_ModifyItems_Request| { &m.steamid },
                |m: &mut CInventory_ModifyItems_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CInventory_ModifyItems_Request_ItemPropertyUpdate>>(
                "updates",
                |m: &CInventory_ModifyItems_Request| { &m.updates },
                |m: &mut CInventory_ModifyItems_Request| { &mut m.updates },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "timestamp",
                |m: &CInventory_ModifyItems_Request| { &m.timestamp },
                |m: &mut CInventory_ModifyItems_Request| { &mut m.timestamp },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_ModifyItems_Request>(
                "CInventory_ModifyItems_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CInventory_ModifyItems_Request_ItemPropertyUpdate {
    // message fields
    itemid: ::std::option::Option<u64>,
    remove_property: ::std::option::Option<bool>,
    property_name: ::protobuf::SingularField<::std::string::String>,
    property_value_bool: ::std::option::Option<bool>,
    property_value_int: ::std::option::Option<i64>,
    property_value_string: ::protobuf::SingularField<::std::string::String>,
    property_value_float: ::std::option::Option<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint64 itemid = 1;


    pub fn get_itemid(&self) -> u64 {
        self.itemid.unwrap_or(0)
    }
    pub fn clear_itemid(&mut self) {
        self.itemid = ::std::option::Option::None;
    }

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional bool remove_property = 2;


    pub fn get_remove_property(&self) -> bool {
        self.remove_property.unwrap_or(false)
    }
    pub fn clear_remove_property(&mut self) {
        self.remove_property = ::std::option::Option::None;
    }

    pub fn has_remove_property(&self) -> bool {
        self.remove_property.is_some()
    }

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

    // optional string property_name = 3;


    pub fn get_property_name(&self) -> &str {
        match self.property_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_property_name(&mut self) {
        self.property_name.clear();
    }

    pub fn has_property_name(&self) -> bool {
        self.property_name.is_some()
    }

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

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

    // optional bool property_value_bool = 4;


    pub fn get_property_value_bool(&self) -> bool {
        self.property_value_bool.unwrap_or(false)
    }
    pub fn clear_property_value_bool(&mut self) {
        self.property_value_bool = ::std::option::Option::None;
    }

    pub fn has_property_value_bool(&self) -> bool {
        self.property_value_bool.is_some()
    }

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

    // optional int64 property_value_int = 5;


    pub fn get_property_value_int(&self) -> i64 {
        self.property_value_int.unwrap_or(0)
    }
    pub fn clear_property_value_int(&mut self) {
        self.property_value_int = ::std::option::Option::None;
    }

    pub fn has_property_value_int(&self) -> bool {
        self.property_value_int.is_some()
    }

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

    // optional string property_value_string = 6;


    pub fn get_property_value_string(&self) -> &str {
        match self.property_value_string.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_property_value_string(&mut self) {
        self.property_value_string.clear();
    }

    pub fn has_property_value_string(&self) -> bool {
        self.property_value_string.is_some()
    }

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

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

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

    // optional float property_value_float = 7;


    pub fn get_property_value_float(&self) -> f32 {
        self.property_value_float.unwrap_or(0.)
    }
    pub fn clear_property_value_float(&mut self) {
        self.property_value_float = ::std::option::Option::None;
    }

    pub fn has_property_value_float(&self) -> bool {
        self.property_value_float.is_some()
    }

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

impl ::protobuf::Message for CInventory_ModifyItems_Request_ItemPropertyUpdate {
    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_uint64()?;
                    self.itemid = ::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.remove_property = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.property_name)?;
                },
                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.property_value_bool = ::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_int64()?;
                    self.property_value_int = ::std::option::Option::Some(tmp);
                },
                6 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.property_value_string)?;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_float()?;
                    self.property_value_float = ::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.itemid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.remove_property {
            my_size += 2;
        }
        if let Some(ref v) = self.property_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.property_value_bool {
            my_size += 2;
        }
        if let Some(v) = self.property_value_int {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.property_value_string.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        if let Some(v) = self.property_value_float {
            my_size += 5;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.itemid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.remove_property {
            os.write_bool(2, v)?;
        }
        if let Some(ref v) = self.property_name.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(v) = self.property_value_bool {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.property_value_int {
            os.write_int64(5, v)?;
        }
        if let Some(ref v) = self.property_value_string.as_ref() {
            os.write_string(6, &v)?;
        }
        if let Some(v) = self.property_value_float {
            os.write_float(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() -> CInventory_ModifyItems_Request_ItemPropertyUpdate {
        CInventory_ModifyItems_Request_ItemPropertyUpdate::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "itemid",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.itemid },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.itemid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "remove_property",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.remove_property },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.remove_property },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "property_name",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.property_name },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.property_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "property_value_bool",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.property_value_bool },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.property_value_bool },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "property_value_int",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.property_value_int },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.property_value_int },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "property_value_string",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.property_value_string },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.property_value_string },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "property_value_float",
                |m: &CInventory_ModifyItems_Request_ItemPropertyUpdate| { &m.property_value_float },
                |m: &mut CInventory_ModifyItems_Request_ItemPropertyUpdate| { &mut m.property_value_float },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_ModifyItems_Request_ItemPropertyUpdate>(
                "CInventory_ModifyItems_Request.ItemPropertyUpdate",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_ModifyItems_Request_ItemPropertyUpdate {
    fn clear(&mut self) {
        self.itemid = ::std::option::Option::None;
        self.remove_property = ::std::option::Option::None;
        self.property_name.clear();
        self.property_value_bool = ::std::option::Option::None;
        self.property_value_int = ::std::option::Option::None;
        self.property_value_string.clear();
        self.property_value_float = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 itemdefid = 2;


    pub fn get_itemdefid(&self) -> u64 {
        self.itemdefid.unwrap_or(0)
    }
    pub fn clear_itemdefid(&mut self) {
        self.itemdefid = ::std::option::Option::None;
    }

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CInventory_ConsumeItem_Request {
    // message fields
    appid: ::std::option::Option<u32>,
    itemid: ::std::option::Option<u64>,
    quantity: ::std::option::Option<u32>,
    timestamp: ::protobuf::SingularField<::std::string::String>,
    steamid: ::std::option::Option<u64>,
    requestid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 itemid = 2;


    pub fn get_itemid(&self) -> u64 {
        self.itemid.unwrap_or(0)
    }
    pub fn clear_itemid(&mut self) {
        self.itemid = ::std::option::Option::None;
    }

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional uint32 quantity = 3;


    pub fn get_quantity(&self) -> u32 {
        self.quantity.unwrap_or(0)
    }
    pub fn clear_quantity(&mut self) {
        self.quantity = ::std::option::Option::None;
    }

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

    // optional string timestamp = 4;


    pub fn get_timestamp(&self) -> &str {
        match self.timestamp.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_timestamp(&mut self) {
        self.timestamp.clear();
    }

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

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

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

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

    // optional uint64 steamid = 5;


    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 requestid = 6;


    pub fn get_requestid(&self) -> u64 {
        self.requestid.unwrap_or(0)
    }
    pub fn clear_requestid(&mut self) {
        self.requestid = ::std::option::Option::None;
    }

    pub fn has_requestid(&self) -> bool {
        self.requestid.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.itemid = ::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.quantity = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.timestamp)?;
                },
                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.steamid = ::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_uint64()?;
                    self.requestid = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.itemid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.quantity {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.timestamp.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.steamid {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.requestid {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.itemid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.quantity {
            os.write_uint32(3, v)?;
        }
        if let Some(ref v) = self.timestamp.as_ref() {
            os.write_string(4, &v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.requestid {
            os.write_uint64(6, 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() -> CInventory_ConsumeItem_Request {
        CInventory_ConsumeItem_Request::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CInventory_ConsumeItem_Request| { &m.appid },
                |m: &mut CInventory_ConsumeItem_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "itemid",
                |m: &CInventory_ConsumeItem_Request| { &m.itemid },
                |m: &mut CInventory_ConsumeItem_Request| { &mut m.itemid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "quantity",
                |m: &CInventory_ConsumeItem_Request| { &m.quantity },
                |m: &mut CInventory_ConsumeItem_Request| { &mut m.quantity },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "timestamp",
                |m: &CInventory_ConsumeItem_Request| { &m.timestamp },
                |m: &mut CInventory_ConsumeItem_Request| { &mut m.timestamp },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "steamid",
                |m: &CInventory_ConsumeItem_Request| { &m.steamid },
                |m: &mut CInventory_ConsumeItem_Request| { &mut m.steamid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "requestid",
                |m: &CInventory_ConsumeItem_Request| { &m.requestid },
                |m: &mut CInventory_ConsumeItem_Request| { &mut m.requestid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_ConsumeItem_Request>(
                "CInventory_ConsumeItem_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_ConsumeItem_Request {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.itemid = ::std::option::Option::None;
        self.quantity = ::std::option::Option::None;
        self.timestamp.clear();
        self.steamid = ::std::option::Option::None;
        self.requestid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 itemdefid = 2;


    pub fn get_itemdefid(&self) -> u64 {
        self.itemdefid.unwrap_or(0)
    }
    pub fn clear_itemdefid(&mut self) {
        self.itemdefid = ::std::option::Option::None;
    }

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

    // optional string droptime = 3;


    pub fn get_droptime(&self) -> &str {
        match self.droptime.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_droptime(&mut self) {
        self.droptime.clear();
    }

    pub fn has_droptime(&self) -> bool {
        self.droptime.is_some()
    }

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.itemdefid {
            os.write_uint64(2, v)?;
        }
        if let Some(ref v) = self.droptime.as_ref() {
            os.write_string(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() -> CInventory_DevSetNextDrop_Request {
        CInventory_DevSetNextDrop_Request::new()
    }

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 itemid = 2;


    pub fn get_itemid(&self) -> u64 {
        self.itemid.unwrap_or(0)
    }
    pub fn clear_itemid(&mut self) {
        self.itemid = ::std::option::Option::None;
    }

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional uint32 quantity = 3;


    pub fn get_quantity(&self) -> u32 {
        self.quantity.unwrap_or(0)
    }
    pub fn clear_quantity(&mut self) {
        self.quantity = ::std::option::Option::None;
    }

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

    // optional uint64 steamid = 5;


    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 CInventory_SplitItemStack_Request {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.itemid = ::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.quantity = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.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.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.itemid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.quantity {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.steamid {
            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.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.itemid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.quantity {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_uint64(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() -> CInventory_SplitItemStack_Request {
        CInventory_SplitItemStack_Request::new()
    }

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

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

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

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional uint64 fromitemid = 2;


    pub fn get_fromitemid(&self) -> u64 {
        self.fromitemid.unwrap_or(0)
    }
    pub fn clear_fromitemid(&mut self) {
        self.fromitemid = ::std::option::Option::None;
    }

    pub fn has_fromitemid(&self) -> bool {
        self.fromitemid.is_some()
    }

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

    // optional uint64 destitemid = 3;


    pub fn get_destitemid(&self) -> u64 {
        self.destitemid.unwrap_or(0)
    }
    pub fn clear_destitemid(&mut self) {
        self.destitemid = ::std::option::Option::None;
    }

    pub fn has_destitemid(&self) -> bool {
        self.destitemid.is_some()
    }

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

    // optional uint32 quantity = 4;


    pub fn get_quantity(&self) -> u32 {
        self.quantity.unwrap_or(0)
    }
    pub fn clear_quantity(&mut self) {
        self.quantity = ::std::option::Option::None;
    }

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

    // optional fixed64 steamid = 7;


    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 CInventory_CombineItemStacks_Request {
    fn is_initialized(&self) -> bool {
        true
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.fromitemid {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.destitemid {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.quantity {
            os.write_uint32(4, v)?;
        }
        if let Some(v) = self.steamid {
            os.write_fixed64(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() -> CInventory_CombineItemStacks_Request {
        CInventory_CombineItemStacks_Request::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CInventory_CombineItemStacks_Request| { &m.appid },
                |m: &mut CInventory_CombineItemStacks_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "fromitemid",
                |m: &CInventory_CombineItemStacks_Request| { &m.fromitemid },
                |m: &mut CInventory_CombineItemStacks_Request| { &mut m.fromitemid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "destitemid",
                |m: &CInventory_CombineItemStacks_Request| { &m.destitemid },
                |m: &mut CInventory_CombineItemStacks_Request| { &mut m.destitemid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "quantity",
                |m: &CInventory_CombineItemStacks_Request| { &m.quantity },
                |m: &mut CInventory_CombineItemStacks_Request| { &mut m.quantity },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "steamid",
                |m: &CInventory_CombineItemStacks_Request| { &m.steamid },
                |m: &mut CInventory_CombineItemStacks_Request| { &mut m.steamid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_CombineItemStacks_Request>(
                "CInventory_CombineItemStacks_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_CombineItemStacks_Request {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.fromitemid = ::std::option::Option::None;
        self.destitemid = ::std::option::Option::None;
        self.quantity = ::std::option::Option::None;
        self.steamid = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        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() -> CInventory_GetItemDefMeta_Request {
        CInventory_GetItemDefMeta_Request::new()
    }

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

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

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

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

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

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

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

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

    // optional uint32 modified = 1;


    pub fn get_modified(&self) -> u32 {
        self.modified.unwrap_or(0)
    }
    pub fn clear_modified(&mut self) {
        self.modified = ::std::option::Option::None;
    }

    pub fn has_modified(&self) -> bool {
        self.modified.is_some()
    }

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

    // optional string digest = 2;


    pub fn get_digest(&self) -> &str {
        match self.digest.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_digest(&mut self) {
        self.digest.clear();
    }

    pub fn has_digest(&self) -> bool {
        self.digest.is_some()
    }

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

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

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

impl ::protobuf::Message for CInventory_GetItemDefMeta_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.modified = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.digest)?;
                },
                _ => {
                    ::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.modified {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.digest.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

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

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

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

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

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

    fn new() -> CInventory_GetItemDefMeta_Response {
        CInventory_GetItemDefMeta_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>(
                "modified",
                |m: &CInventory_GetItemDefMeta_Response| { &m.modified },
                |m: &mut CInventory_GetItemDefMeta_Response| { &mut m.modified },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "digest",
                |m: &CInventory_GetItemDefMeta_Response| { &m.digest },
                |m: &mut CInventory_GetItemDefMeta_Response| { &mut m.digest },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_GetItemDefMeta_Response>(
                "CInventory_GetItemDefMeta_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional int32 ecurrency = 1;


    pub fn get_ecurrency(&self) -> i32 {
        self.ecurrency.unwrap_or(0)
    }
    pub fn clear_ecurrency(&mut self) {
        self.ecurrency = ::std::option::Option::None;
    }

    pub fn has_ecurrency(&self) -> bool {
        self.ecurrency.is_some()
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CInventory_PurchaseInit_Request {
    // message fields
    appid: ::std::option::Option<u32>,
    language: ::std::option::Option<i32>,
    pub line_items: ::protobuf::RepeatedField<CInventory_PurchaseInit_Request_LineItem>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional int32 language = 2;


    pub fn get_language(&self) -> i32 {
        self.language.unwrap_or(0)
    }
    pub fn clear_language(&mut self) {
        self.language = ::std::option::Option::None;
    }

    pub fn has_language(&self) -> bool {
        self.language.is_some()
    }

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

    // repeated .CInventory_PurchaseInit_Request.LineItem line_items = 3;


    pub fn get_line_items(&self) -> &[CInventory_PurchaseInit_Request_LineItem] {
        &self.line_items
    }
    pub fn clear_line_items(&mut self) {
        self.line_items.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_line_items(&mut self) -> &mut ::protobuf::RepeatedField<CInventory_PurchaseInit_Request_LineItem> {
        &mut self.line_items
    }

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

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.appid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.language {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.line_items {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.language {
            os.write_int32(2, v)?;
        }
        for v in &self.line_items {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "appid",
                |m: &CInventory_PurchaseInit_Request| { &m.appid },
                |m: &mut CInventory_PurchaseInit_Request| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "language",
                |m: &CInventory_PurchaseInit_Request| { &m.language },
                |m: &mut CInventory_PurchaseInit_Request| { &mut m.language },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CInventory_PurchaseInit_Request_LineItem>>(
                "line_items",
                |m: &CInventory_PurchaseInit_Request| { &m.line_items },
                |m: &mut CInventory_PurchaseInit_Request| { &mut m.line_items },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_PurchaseInit_Request>(
                "CInventory_PurchaseInit_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // optional uint64 itemdefid = 1;


    pub fn get_itemdefid(&self) -> u64 {
        self.itemdefid.unwrap_or(0)
    }
    pub fn clear_itemdefid(&mut self) {
        self.itemdefid = ::std::option::Option::None;
    }

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

    // optional uint32 quantity = 2;


    pub fn get_quantity(&self) -> u32 {
        self.quantity.unwrap_or(0)
    }
    pub fn clear_quantity(&mut self) {
        self.quantity = ::std::option::Option::None;
    }

    pub fn has_quantity(&self) -> bool {
        self.quantity.is_some()
    }

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

impl ::protobuf::Message for CInventory_PurchaseInit_Request_LineItem {
    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_uint64()?;
                    self.itemdefid = ::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.quantity = ::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.itemdefid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.quantity {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // optional uint64 orderid = 1;


    pub fn get_orderid(&self) -> u64 {
        self.orderid.unwrap_or(0)
    }
    pub fn clear_orderid(&mut self) {
        self.orderid = ::std::option::Option::None;
    }

    pub fn has_orderid(&self) -> bool {
        self.orderid.is_some()
    }

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

    // optional uint64 transid = 2;


    pub fn get_transid(&self) -> u64 {
        self.transid.unwrap_or(0)
    }
    pub fn clear_transid(&mut self) {
        self.transid = ::std::option::Option::None;
    }

    pub fn has_transid(&self) -> bool {
        self.transid.is_some()
    }

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

impl ::protobuf::Message for CInventory_PurchaseInit_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_uint64()?;
                    self.orderid = ::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.transid = ::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.orderid {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.transid {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

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

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

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

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

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

    fn new() -> CInventory_PurchaseInit_Response {
        CInventory_PurchaseInit_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::ProtobufTypeUint64>(
                "orderid",
                |m: &CInventory_PurchaseInit_Response| { &m.orderid },
                |m: &mut CInventory_PurchaseInit_Response| { &mut m.orderid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "transid",
                |m: &CInventory_PurchaseInit_Response| { &m.transid },
                |m: &mut CInventory_PurchaseInit_Response| { &mut m.transid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_PurchaseInit_Response>(
                "CInventory_PurchaseInit_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CInventory_PurchaseFinalize_Request {
    // message fields
    appid: ::std::option::Option<u32>,
    language: ::std::option::Option<i32>,
    orderid: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional int32 language = 2;


    pub fn get_language(&self) -> i32 {
        self.language.unwrap_or(0)
    }
    pub fn clear_language(&mut self) {
        self.language = ::std::option::Option::None;
    }

    pub fn has_language(&self) -> bool {
        self.language.is_some()
    }

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

    // optional uint64 orderid = 3;


    pub fn get_orderid(&self) -> u64 {
        self.orderid.unwrap_or(0)
    }
    pub fn clear_orderid(&mut self) {
        self.orderid = ::std::option::Option::None;
    }

    pub fn has_orderid(&self) -> bool {
        self.orderid.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.appid = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.language = ::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.orderid = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.language {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.orderid {
            os.write_uint64(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() -> CInventory_PurchaseFinalize_Request {
        CInventory_PurchaseFinalize_Request::new()
    }

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

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

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

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

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

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

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

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

    // optional uint64 itemdefid = 1;


    pub fn get_itemdefid(&self) -> u64 {
        self.itemdefid.unwrap_or(0)
    }
    pub fn clear_itemdefid(&mut self) {
        self.itemdefid = ::std::option::Option::None;
    }

    pub fn has_itemdefid(&self) -> bool {
        self.itemdefid.is_some()
    }

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

    // optional fixed64 itemid = 2;


    pub fn get_itemid(&self) -> u64 {
        self.itemid.unwrap_or(0)
    }
    pub fn clear_itemid(&mut self) {
        self.itemid = ::std::option::Option::None;
    }

    pub fn has_itemid(&self) -> bool {
        self.itemid.is_some()
    }

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

    // optional string tags = 3;


    pub fn get_tags(&self) -> &str {
        match self.tags.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_tags(&mut self) {
        self.tags.clear();
    }

    pub fn has_tags(&self) -> bool {
        self.tags.is_some()
    }

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.itemdefid {
            os.write_uint64(1, v)?;
        }
        if let Some(v) = self.itemid {
            os.write_fixed64(2, v)?;
        }
        if let Some(ref v) = self.tags.as_ref() {
            os.write_string(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() -> CInventory_InspectItem_Request {
        CInventory_InspectItem_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::ProtobufTypeUint64>(
                "itemdefid",
                |m: &CInventory_InspectItem_Request| { &m.itemdefid },
                |m: &mut CInventory_InspectItem_Request| { &mut m.itemdefid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
                "itemid",
                |m: &CInventory_InspectItem_Request| { &m.itemid },
                |m: &mut CInventory_InspectItem_Request| { &mut m.itemid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "tags",
                |m: &CInventory_InspectItem_Request| { &m.tags },
                |m: &mut CInventory_InspectItem_Request| { &mut m.tags },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CInventory_InspectItem_Request>(
                "CInventory_InspectItem_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CInventory_InspectItem_Request {
    fn clear(&mut self) {
        self.itemdefid = ::std::option::Option::None;
        self.itemid = ::std::option::Option::None;
        self.tags.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // optional uint32 appid = 1;


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

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

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

    // optional .CInventory_Response inventory_response = 2;


    pub fn get_inventory_response(&self) -> &CInventory_Response {
        self.inventory_response.as_ref().unwrap_or_else(|| <CInventory_Response as ::protobuf::Message>::default_instance())
    }
    pub fn clear_inventory_response(&mut self) {
        self.inventory_response.clear();
    }

    pub fn has_inventory_response(&self) -> bool {
        self.inventory_response.is_some()
    }

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

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

    // Take field
    pub fn take_inventory_response(&mut self) -> CInventory_Response {
        self.inventory_response.take().unwrap_or_else(|| CInventory_Response::new())
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.appid {
            os.write_uint32(1, v)?;
        }
        if let Some(ref v) = self.inventory_response.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        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() -> CInventoryClient_NewItems_Notification {
        CInventoryClient_NewItems_Notification::new()
    }

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

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n)steammessages_inventory.steamclient.proto\x1a,steammessages_unified_b\
    ase.steamclient.proto\"Q\n\x1fCInventory_GetInventory_Request\x12\x14\n\
    \x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x18\n\x07steamid\x18\x02\x20\
    \x01(\x04R\x07steamid\"\xfe\x01\n\x13CInventory_Response\x12\x12\n\x04et\
    ag\x18\x01\x20\x01(\tR\x04etag\x12&\n\x0eremoveditemids\x18\x02\x20\x03(\
    \x04R\x0eremoveditemids\x12\x1b\n\titem_json\x18\x03\x20\x01(\tR\x08item\
    Json\x12!\n\x0citemdef_json\x18\x04\x20\x01(\tR\x0bitemdefJson\x12\x16\n\
    \x06ticket\x18\x05\x20\x01(\x0cR\x06ticket\x12S\n\x08replayed\x18\x06\
    \x20\x01(\x08R\x08replayedB7\x82\xb5\x183If\x20true,\x20the\x20requestid\
    \x20given\x20was\x20processed\x20earlier.\"\xd3\x01\n\x1fCInventory_Exch\
    angeItem_Request\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x18\
    \n\x07steamid\x18\x02\x20\x01(\x04R\x07steamid\x12(\n\x0fmaterialsitemid\
    \x18\x03\x20\x03(\x04R\x0fmaterialsitemid\x12,\n\x11materialsquantity\
    \x18\x04\x20\x03(\rR\x11materialsquantity\x12(\n\x0foutputitemdefid\x18\
    \x05\x20\x01(\x04R\x0foutputitemdefid\"_\n-CInventory_GetEligiblePromoIt\
    emDefIDs_Request\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x18\
    \n\x07steamid\x18\x02\x20\x01(\x04R\x07steamid\"P\n.CInventory_GetEligib\
    lePromoItemDefIDs_Response\x12\x1e\n\nitemdefids\x18\x01\x20\x03(\x04R\n\
    itemdefids\"\xa7\x04\n\x1aCInventory_AddItem_Request\x12\x14\n\x05appid\
    \x18\x01\x20\x01(\rR\x05appid\x12\x1c\n\titemdefid\x18\x02\x20\x03(\x04R\
    \titemdefid\x12$\n\ritempropsjson\x18\x03\x20\x03(\tR\ritempropsjson\x12\
    \x18\n\x07steamid\x18\x04\x20\x01(\x04R\x07steamid\x12d\n\x06notify\x18\
    \x05\x20\x01(\x08R\x06notifyBL\x82\xb5\x18HShould\x20notify\x20the\x20us\
    er\x20that\x20the\x20item\x20was\x20added\x20to\x20their\x20Steam\x20Inv\
    entory.\x12\x1c\n\trequestid\x18\x06\x20\x01(\x04R\trequestid\x12|\n\x11\
    trade_restriction\x18\x07\x20\x01(\x08R\x10tradeRestrictionBO\x82\xb5\
    \x18KIf\x20true,\x20apply\x20the\x20default\x20trade\x20and\x20market\
    \x20restriction\x20times\x20to\x20this\x20item.\x12\x92\x01\n\x0bis_purc\
    hase\x18\x08\x20\x01(\x08:\x05falseR\nisPurchaseBj\x82\xb5\x18fIf\x20set\
    ,\x20treat\x20requestid\x20as\x20a\x20txnid\x20and\x20create\x20this\x20\
    item\x20as\x20a\x20result\x20of\x20user\x20microtransaction\x20purchase.\
    \"\xfd\x03\n\x1eCInventory_ModifyItems_Request\x12\x14\n\x05appid\x18\
    \x01\x20\x01(\rR\x05appid\x12\x18\n\x07steamid\x18\x02\x20\x01(\x04R\x07\
    steamid\x12L\n\x07updates\x18\x03\x20\x03(\x0b22.CInventory_ModifyItems_\
    Request.ItemPropertyUpdateR\x07updates\x12\x1c\n\ttimestamp\x18\x04\x20\
    \x01(\rR\ttimestamp\x1a\xbe\x02\n\x12ItemPropertyUpdate\x12\x16\n\x06ite\
    mid\x18\x01\x20\x01(\x04R\x06itemid\x12'\n\x0fremove_property\x18\x02\
    \x20\x01(\x08R\x0eremoveProperty\x12#\n\rproperty_name\x18\x03\x20\x01(\
    \tR\x0cpropertyName\x12.\n\x13property_value_bool\x18\x04\x20\x01(\x08R\
    \x11propertyValueBool\x12,\n\x12property_value_int\x18\x05\x20\x01(\x03R\
    \x10propertyValueInt\x122\n\x15property_value_string\x18\x06\x20\x01(\tR\
    \x13propertyValueString\x120\n\x14property_value_float\x18\x07\x20\x01(\
    \x02R\x12propertyValueFloat\"X\n\"CInventory_ConsumePlaytime_Request\x12\
    \x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x1c\n\titemdefid\x18\
    \x02\x20\x01(\x04R\titemdefid\"\xc0\x01\n\x1eCInventory_ConsumeItem_Requ\
    est\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x16\n\x06itemid\
    \x18\x02\x20\x01(\x04R\x06itemid\x12\x1a\n\x08quantity\x18\x03\x20\x01(\
    \rR\x08quantity\x12\x1c\n\ttimestamp\x18\x04\x20\x01(\tR\ttimestamp\x12\
    \x18\n\x07steamid\x18\x05\x20\x01(\x04R\x07steamid\x12\x1c\n\trequestid\
    \x18\x06\x20\x01(\x04R\trequestid\"s\n!CInventory_DevSetNextDrop_Request\
    \x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x1c\n\titemdefid\
    \x18\x02\x20\x01(\x04R\titemdefid\x12\x1a\n\x08droptime\x18\x03\x20\x01(\
    \tR\x08droptime\"\x87\x01\n!CInventory_SplitItemStack_Request\x12\x14\n\
    \x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x16\n\x06itemid\x18\x02\x20\
    \x01(\x04R\x06itemid\x12\x1a\n\x08quantity\x18\x03\x20\x01(\rR\x08quanti\
    ty\x12\x18\n\x07steamid\x18\x05\x20\x01(\x04R\x07steamid\"\xb2\x01\n$CIn\
    ventory_CombineItemStacks_Request\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\
    \x05appid\x12\x1e\n\nfromitemid\x18\x02\x20\x01(\x04R\nfromitemid\x12\
    \x1e\n\ndestitemid\x18\x03\x20\x01(\x04R\ndestitemid\x12\x1a\n\x08quanti\
    ty\x18\x04\x20\x01(\rR\x08quantity\x12\x18\n\x07steamid\x18\x07\x20\x01(\
    \x06R\x07steamid\"9\n!CInventory_GetItemDefMeta_Request\x12\x14\n\x05app\
    id\x18\x01\x20\x01(\rR\x05appid\"X\n\"CInventory_GetItemDefMeta_Response\
    \x12\x1a\n\x08modified\x18\x01\x20\x01(\rR\x08modified\x12\x16\n\x06dige\
    st\x18\x02\x20\x01(\tR\x06digest\"(\n&CInventory_GetUserPurchaseInfo_Req\
    uest\"G\n'CInventory_GetUserPurchaseInfo_Response\x12\x1c\n\tecurrency\
    \x18\x01\x20\x01(\x05R\tecurrency\"\xe3\x01\n\x1fCInventory_PurchaseInit\
    _Request\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x1a\n\x08la\
    nguage\x18\x02\x20\x01(\x05R\x08language\x12H\n\nline_items\x18\x03\x20\
    \x03(\x0b2).CInventory_PurchaseInit_Request.LineItemR\tlineItems\x1aD\n\
    \x08LineItem\x12\x1c\n\titemdefid\x18\x01\x20\x01(\x04R\titemdefid\x12\
    \x1a\n\x08quantity\x18\x02\x20\x01(\rR\x08quantity\"V\n\x20CInventory_Pu\
    rchaseInit_Response\x12\x18\n\x07orderid\x18\x01\x20\x01(\x04R\x07orderi\
    d\x12\x18\n\x07transid\x18\x02\x20\x01(\x04R\x07transid\"q\n#CInventory_\
    PurchaseFinalize_Request\x12\x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\
    \x12\x1a\n\x08language\x18\x02\x20\x01(\x05R\x08language\x12\x18\n\x07or\
    derid\x18\x03\x20\x01(\x04R\x07orderid\"j\n\x1eCInventory_InspectItem_Re\
    quest\x12\x1c\n\titemdefid\x18\x01\x20\x01(\x04R\titemdefid\x12\x16\n\
    \x06itemid\x18\x02\x20\x01(\x06R\x06itemid\x12\x12\n\x04tags\x18\x03\x20\
    \x01(\tR\x04tags\"\x83\x01\n&CInventoryClient_NewItems_Notification\x12\
    \x14\n\x05appid\x18\x01\x20\x01(\rR\x05appid\x12C\n\x12inventory_respons\
    e\x18\x02\x20\x01(\x0b2\x14.CInventory_ResponseR\x11inventoryResponse2\
    \xbb\x10\n\tInventory\x12z\n\x0cGetInventory\x12\x20.CInventory_GetInven\
    tory_Request\x1a\x14.CInventory_Response\"2\x82\xb5\x18.Retrieves\x20a\
    \x20users\x20inventory\x20as\x20a\x20big\x20JSON\x20blob\x12o\n\x0cExcha\
    ngeItem\x12\x20.CInventory_ExchangeItem_Request\x1a\x14.CInventory_Respo\
    nse\"'\x82\xb5\x18#Craft\x20an\x20item\x20in\x20a\x20user's\x20inventory\
    \x12\xbd\x01\n\x1aGetEligiblePromoItemDefIDs\x12..CInventory_GetEligible\
    PromoItemDefIDs_Request\x1a/.CInventory_GetEligiblePromoItemDefIDs_Respo\
    nse\">\x82\xb5\x18:Returns\x20a\x20list\x20of\x20promo\x20item\x20defs\
    \x20the\x20user\x20is\x20eligible\x20for\x12n\n\x0cAddPromoItem\x12\x1b.\
    CInventory_AddItem_Request\x1a\x14.CInventory_Response\"+\x82\xb5\x18'Ad\
    ds\x20a\x20promo\x20item\x20to\x20a\x20user's\x20inventory\x12\x89\x01\n\
    \x0fSafeModifyItems\x12\x1f.CInventory_ModifyItems_Request\x1a\x14.CInve\
    ntory_Response\"?\x82\xb5\x18;Modify\x20an\x20item\x20in\x20a\x20user's\
    \x20inventory\x20(safe\x20properties\x20only)\x12\x87\x01\n\x0fConsumePl\
    aytime\x12#.CInventory_ConsumePlaytime_Request\x1a\x14.CInventory_Respon\
    se\"9\x82\xb5\x185Consumes\x20playtime\x20and\x20possibly\x20returns\x20\
    a\x20granted\x20item\x12Y\n\x0bConsumeItem\x12\x1f.CInventory_ConsumeIte\
    m_Request\x1a\x14.CInventory_Response\"\x13\x82\xb5\x18\x0fConsume\x20an\
    \x20item\x12n\n\x0fDevGenerateItem\x12\x1b.CInventory_AddItem_Request\
    \x1a\x14.CInventory_Response\"(\x82\xb5\x18$Grant\x20an\x20item\x20when\
    \x20in\x20developer\x20mode\x12_\n\x0eDevSetNextDrop\x12\".CInventory_De\
    vSetNextDrop_Request\x1a\x14.CInventory_Response\"\x13\x82\xb5\x18\x0fCo\
    nsume\x20an\x20item\x12s\n\x0eSplitItemStack\x12\".CInventory_SplitItemS\
    tack_Request\x1a\x14.CInventory_Response\"'\x82\xb5\x18#Split\x20an\x20i\
    tem\x20stack\x20into\x20two\x20stacks\x12q\n\x11CombineItemStacks\x12%.C\
    Inventory_CombineItemStacks_Request\x1a\x14.CInventory_Response\"\x1f\
    \x82\xb5\x18\x1bCombine\x20two\x20stacks\x20of\x20items\x12\x9c\x01\n\
    \x0eGetItemDefMeta\x12\".CInventory_GetItemDefMeta_Request\x1a#.CInvento\
    ry_GetItemDefMeta_Response\"A\x82\xb5\x18=Get\x20metadata\x20about\x20th\
    e\x20current\x20item\x20definition\x20for\x20this\x20game.\x12\xa7\x01\n\
    \x13GetUserPurchaseInfo\x12'.CInventory_GetUserPurchaseInfo_Request\x1a(\
    .CInventory_GetUserPurchaseInfo_Response\"=\x82\xb5\x189Returns\x20infor\
    mation\x20about\x20the\x20user\x20such\x20as\x20their\x20currency\x12|\n\
    \x0cPurchaseInit\x12\x20.CInventory_PurchaseInit_Request\x1a!.CInventory\
    _PurchaseInit_Response\"'\x82\xb5\x18#Initializes\x20a\x20purchase\x20fo\
    r\x20the\x20user\x12u\n\x10PurchaseFinalize\x12$.CInventory_PurchaseFina\
    lize_Request\x1a\x14.CInventory_Response\"%\x82\xb5\x18!Finalizes\x20a\
    \x20purchase\x20for\x20the\x20user\x12x\n\x0bInspectItem\x12\x1f.CInvent\
    ory_InspectItem_Request\x1a\x14.CInventory_Response\"2\x82\xb5\x18.Get\
    \x20item\x20detail\x20given\x20a\x20valid\x20inspection\x20token\x1a/\
    \x82\xb5\x18+A\x20service\x20that\x20provides\x20access\x20to\x20invento\
    ry2\xc4\x01\n\x0fInventoryClient\x12z\n\x0eNotifyNewItems\x12'.CInventor\
    yClient_NewItems_Notification\x1a\x0b.NoResponse\"2\x82\xb5\x18.Notify\
    \x20client\x20that\x20the\x20user\x20received\x20new\x20items\x1a5\xc0\
    \xb5\x18\x02\x82\xb5\x18-Client\x20notifications\x20inventory\x20service\
    \x20eventsB\x03\x80\x01\x01J\xb3<\n\x07\x12\x05\0\0\xde\x01\x01\n\t\n\
    \x02\x03\0\x12\x03\0\06\n\x08\n\x01\x08\x12\x03\x02\0\"\n\t\n\x02\x08\
    \x10\x12\x03\x02\0\"\n\n\n\x02\x04\0\x12\x04\x04\0\x07\x01\n\n\n\x03\x04\
    \0\x01\x12\x03\x04\x08'\n\x0b\n\x04\x04\0\x02\0\x12\x03\x05\x08\"\n\x0c\
    \n\x05\x04\0\x02\0\x04\x12\x03\x05\x08\x10\n\x0c\n\x05\x04\0\x02\0\x05\
    \x12\x03\x05\x11\x17\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x05\x18\x1d\n\
    \x0c\n\x05\x04\0\x02\0\x03\x12\x03\x05\x20!\n\x0b\n\x04\x04\0\x02\x01\
    \x12\x03\x06\x08$\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03\x06\x08\x10\n\
    \x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x06\x11\x17\n\x0c\n\x05\x04\0\x02\
    \x01\x01\x12\x03\x06\x18\x1f\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x06\"\
    #\n\n\n\x02\x04\x01\x12\x04\t\0\x10\x01\n\n\n\x03\x04\x01\x01\x12\x03\t\
    \x08\x1b\n\x0b\n\x04\x04\x01\x02\0\x12\x03\n\x08!\n\x0c\n\x05\x04\x01\
    \x02\0\x04\x12\x03\n\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\n\x11\
    \x17\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\n\x18\x1c\n\x0c\n\x05\x04\x01\
    \x02\0\x03\x12\x03\n\x1f\x20\n\x0b\n\x04\x04\x01\x02\x01\x12\x03\x0b\x08\
    +\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\x0b\x08\x10\n\x0c\n\x05\x04\
    \x01\x02\x01\x05\x12\x03\x0b\x11\x17\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\
    \x03\x0b\x18&\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\x0b)*\n\x0b\n\x04\
    \x04\x01\x02\x02\x12\x03\x0c\x08&\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\
    \x03\x0c\x08\x10\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03\x0c\x11\x17\n\
    \x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\x0c\x18!\n\x0c\n\x05\x04\x01\x02\
    \x02\x03\x12\x03\x0c$%\n\x0b\n\x04\x04\x01\x02\x03\x12\x03\r\x08)\n\x0c\
    \n\x05\x04\x01\x02\x03\x04\x12\x03\r\x08\x10\n\x0c\n\x05\x04\x01\x02\x03\
    \x05\x12\x03\r\x11\x17\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\r\x18$\n\
    \x0c\n\x05\x04\x01\x02\x03\x03\x12\x03\r'(\n\x0b\n\x04\x04\x01\x02\x04\
    \x12\x03\x0e\x08\"\n\x0c\n\x05\x04\x01\x02\x04\x04\x12\x03\x0e\x08\x10\n\
    \x0c\n\x05\x04\x01\x02\x04\x05\x12\x03\x0e\x11\x16\n\x0c\n\x05\x04\x01\
    \x02\x04\x01\x12\x03\x0e\x17\x1d\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03\
    \x0e\x20!\n\x0b\n\x04\x04\x01\x02\x05\x12\x03\x0f\x08k\n\x0c\n\x05\x04\
    \x01\x02\x05\x04\x12\x03\x0f\x08\x10\n\x0c\n\x05\x04\x01\x02\x05\x05\x12\
    \x03\x0f\x11\x15\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03\x0f\x16\x1e\n\
    \x0c\n\x05\x04\x01\x02\x05\x03\x12\x03\x0f!\"\n\x0c\n\x05\x04\x01\x02\
    \x05\x08\x12\x03\x0f#j\n\x0f\n\x08\x04\x01\x02\x05\x08\xd0\x86\x03\x12\
    \x03\x0f$i\n\n\n\x02\x04\x02\x12\x04\x12\0\x18\x01\n\n\n\x03\x04\x02\x01\
    \x12\x03\x12\x08'\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x13\x08\"\n\x0c\n\
    \x05\x04\x02\x02\0\x04\x12\x03\x13\x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\
    \x12\x03\x13\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\x13\x18\x1d\n\
    \x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x13\x20!\n\x0b\n\x04\x04\x02\x02\
    \x01\x12\x03\x14\x08$\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03\x14\x08\
    \x10\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03\x14\x11\x17\n\x0c\n\x05\x04\
    \x02\x02\x01\x01\x12\x03\x14\x18\x1f\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\
    \x03\x14\"#\n\x0b\n\x04\x04\x02\x02\x02\x12\x03\x15\x08,\n\x0c\n\x05\x04\
    \x02\x02\x02\x04\x12\x03\x15\x08\x10\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\
    \x03\x15\x11\x17\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03\x15\x18'\n\x0c\
    \n\x05\x04\x02\x02\x02\x03\x12\x03\x15*+\n\x0b\n\x04\x04\x02\x02\x03\x12\
    \x03\x16\x08.\n\x0c\n\x05\x04\x02\x02\x03\x04\x12\x03\x16\x08\x10\n\x0c\
    \n\x05\x04\x02\x02\x03\x05\x12\x03\x16\x11\x17\n\x0c\n\x05\x04\x02\x02\
    \x03\x01\x12\x03\x16\x18)\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\x03\x16,-\
    \n\x0b\n\x04\x04\x02\x02\x04\x12\x03\x17\x08,\n\x0c\n\x05\x04\x02\x02\
    \x04\x04\x12\x03\x17\x08\x10\n\x0c\n\x05\x04\x02\x02\x04\x05\x12\x03\x17\
    \x11\x17\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03\x17\x18'\n\x0c\n\x05\
    \x04\x02\x02\x04\x03\x12\x03\x17*+\n\n\n\x02\x04\x03\x12\x04\x1a\0\x1d\
    \x01\n\n\n\x03\x04\x03\x01\x12\x03\x1a\x085\n\x0b\n\x04\x04\x03\x02\0\
    \x12\x03\x1b\x08\"\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03\x1b\x08\x10\n\
    \x0c\n\x05\x04\x03\x02\0\x05\x12\x03\x1b\x11\x17\n\x0c\n\x05\x04\x03\x02\
    \0\x01\x12\x03\x1b\x18\x1d\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03\x1b\x20\
    !\n\x0b\n\x04\x04\x03\x02\x01\x12\x03\x1c\x08$\n\x0c\n\x05\x04\x03\x02\
    \x01\x04\x12\x03\x1c\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03\x1c\
    \x11\x17\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03\x1c\x18\x1f\n\x0c\n\x05\
    \x04\x03\x02\x01\x03\x12\x03\x1c\"#\n\n\n\x02\x04\x04\x12\x04\x1f\0!\x01\
    \n\n\n\x03\x04\x04\x01\x12\x03\x1f\x086\n\x0b\n\x04\x04\x04\x02\0\x12\
    \x03\x20\x08'\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03\x20\x08\x10\n\x0c\n\
    \x05\x04\x04\x02\0\x05\x12\x03\x20\x11\x17\n\x0c\n\x05\x04\x04\x02\0\x01\
    \x12\x03\x20\x18\"\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03\x20%&\n\n\n\x02\
    \x04\x05\x12\x04#\0,\x01\n\n\n\x03\x04\x05\x01\x12\x03#\x08\"\n\x0b\n\
    \x04\x04\x05\x02\0\x12\x03$\x08\"\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03$\
    \x08\x10\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03$\x11\x17\n\x0c\n\x05\x04\
    \x05\x02\0\x01\x12\x03$\x18\x1d\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03$\
    \x20!\n\x0b\n\x04\x04\x05\x02\x01\x12\x03%\x08&\n\x0c\n\x05\x04\x05\x02\
    \x01\x04\x12\x03%\x08\x10\n\x0c\n\x05\x04\x05\x02\x01\x05\x12\x03%\x11\
    \x17\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03%\x18!\n\x0c\n\x05\x04\x05\
    \x02\x01\x03\x12\x03%$%\n\x0b\n\x04\x04\x05\x02\x02\x12\x03&\x08*\n\x0c\
    \n\x05\x04\x05\x02\x02\x04\x12\x03&\x08\x10\n\x0c\n\x05\x04\x05\x02\x02\
    \x05\x12\x03&\x11\x17\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03&\x18%\n\
    \x0c\n\x05\x04\x05\x02\x02\x03\x12\x03&()\n\x0b\n\x04\x04\x05\x02\x03\
    \x12\x03'\x08$\n\x0c\n\x05\x04\x05\x02\x03\x04\x12\x03'\x08\x10\n\x0c\n\
    \x05\x04\x05\x02\x03\x05\x12\x03'\x11\x17\n\x0c\n\x05\x04\x05\x02\x03\
    \x01\x12\x03'\x18\x1f\n\x0c\n\x05\x04\x05\x02\x03\x03\x12\x03'\"#\n\x0b\
    \n\x04\x04\x05\x02\x04\x12\x03(\x08~\n\x0c\n\x05\x04\x05\x02\x04\x04\x12\
    \x03(\x08\x10\n\x0c\n\x05\x04\x05\x02\x04\x05\x12\x03(\x11\x15\n\x0c\n\
    \x05\x04\x05\x02\x04\x01\x12\x03(\x16\x1c\n\x0c\n\x05\x04\x05\x02\x04\
    \x03\x12\x03(\x1f\x20\n\x0c\n\x05\x04\x05\x02\x04\x08\x12\x03(!}\n\x0f\n\
    \x08\x04\x05\x02\x04\x08\xd0\x86\x03\x12\x03(\"|\n\x0b\n\x04\x04\x05\x02\
    \x05\x12\x03)\x08&\n\x0c\n\x05\x04\x05\x02\x05\x04\x12\x03)\x08\x10\n\
    \x0c\n\x05\x04\x05\x02\x05\x05\x12\x03)\x11\x17\n\x0c\n\x05\x04\x05\x02\
    \x05\x01\x12\x03)\x18!\n\x0c\n\x05\x04\x05\x02\x05\x03\x12\x03)$%\n\x0c\
    \n\x04\x04\x05\x02\x06\x12\x04*\x08\x8c\x01\n\x0c\n\x05\x04\x05\x02\x06\
    \x04\x12\x03*\x08\x10\n\x0c\n\x05\x04\x05\x02\x06\x05\x12\x03*\x11\x15\n\
    \x0c\n\x05\x04\x05\x02\x06\x01\x12\x03*\x16'\n\x0c\n\x05\x04\x05\x02\x06\
    \x03\x12\x03**+\n\r\n\x05\x04\x05\x02\x06\x08\x12\x04*,\x8b\x01\n\x10\n\
    \x08\x04\x05\x02\x06\x08\xd0\x86\x03\x12\x04*-\x8a\x01\n\x0c\n\x04\x04\
    \x05\x02\x07\x12\x04+\x08\xb2\x01\n\x0c\n\x05\x04\x05\x02\x07\x04\x12\
    \x03+\x08\x10\n\x0c\n\x05\x04\x05\x02\x07\x05\x12\x03+\x11\x15\n\x0c\n\
    \x05\x04\x05\x02\x07\x01\x12\x03+\x16!\n\x0c\n\x05\x04\x05\x02\x07\x03\
    \x12\x03+$%\n\r\n\x05\x04\x05\x02\x07\x08\x12\x04+&\xb1\x01\n\x0c\n\x05\
    \x04\x05\x02\x07\x07\x12\x03+16\n\x10\n\x08\x04\x05\x02\x07\x08\xd0\x86\
    \x03\x12\x04+8\xb0\x01\n\n\n\x02\x04\x06\x12\x04.\0=\x01\n\n\n\x03\x04\
    \x06\x01\x12\x03.\x08&\n\x0c\n\x04\x04\x06\x03\0\x12\x04/\x087\t\n\x0c\n\
    \x05\x04\x06\x03\0\x01\x12\x03/\x10\"\n\r\n\x06\x04\x06\x03\0\x02\0\x12\
    \x030\x10+\n\x0e\n\x07\x04\x06\x03\0\x02\0\x04\x12\x030\x10\x18\n\x0e\n\
    \x07\x04\x06\x03\0\x02\0\x05\x12\x030\x19\x1f\n\x0e\n\x07\x04\x06\x03\0\
    \x02\0\x01\x12\x030\x20&\n\x0e\n\x07\x04\x06\x03\0\x02\0\x03\x12\x030)*\
    \n\r\n\x06\x04\x06\x03\0\x02\x01\x12\x031\x102\n\x0e\n\x07\x04\x06\x03\0\
    \x02\x01\x04\x12\x031\x10\x18\n\x0e\n\x07\x04\x06\x03\0\x02\x01\x05\x12\
    \x031\x19\x1d\n\x0e\n\x07\x04\x06\x03\0\x02\x01\x01\x12\x031\x1e-\n\x0e\
    \n\x07\x04\x06\x03\0\x02\x01\x03\x12\x03101\n\r\n\x06\x04\x06\x03\0\x02\
    \x02\x12\x032\x102\n\x0e\n\x07\x04\x06\x03\0\x02\x02\x04\x12\x032\x10\
    \x18\n\x0e\n\x07\x04\x06\x03\0\x02\x02\x05\x12\x032\x19\x1f\n\x0e\n\x07\
    \x04\x06\x03\0\x02\x02\x01\x12\x032\x20-\n\x0e\n\x07\x04\x06\x03\0\x02\
    \x02\x03\x12\x03201\n\r\n\x06\x04\x06\x03\0\x02\x03\x12\x033\x106\n\x0e\
    \n\x07\x04\x06\x03\0\x02\x03\x04\x12\x033\x10\x18\n\x0e\n\x07\x04\x06\
    \x03\0\x02\x03\x05\x12\x033\x19\x1d\n\x0e\n\x07\x04\x06\x03\0\x02\x03\
    \x01\x12\x033\x1e1\n\x0e\n\x07\x04\x06\x03\0\x02\x03\x03\x12\x03345\n\r\
    \n\x06\x04\x06\x03\0\x02\x04\x12\x034\x106\n\x0e\n\x07\x04\x06\x03\0\x02\
    \x04\x04\x12\x034\x10\x18\n\x0e\n\x07\x04\x06\x03\0\x02\x04\x05\x12\x034\
    \x19\x1e\n\x0e\n\x07\x04\x06\x03\0\x02\x04\x01\x12\x034\x1f1\n\x0e\n\x07\
    \x04\x06\x03\0\x02\x04\x03\x12\x03445\n\r\n\x06\x04\x06\x03\0\x02\x05\
    \x12\x035\x10:\n\x0e\n\x07\x04\x06\x03\0\x02\x05\x04\x12\x035\x10\x18\n\
    \x0e\n\x07\x04\x06\x03\0\x02\x05\x05\x12\x035\x19\x1f\n\x0e\n\x07\x04\
    \x06\x03\0\x02\x05\x01\x12\x035\x205\n\x0e\n\x07\x04\x06\x03\0\x02\x05\
    \x03\x12\x03589\n\r\n\x06\x04\x06\x03\0\x02\x06\x12\x036\x108\n\x0e\n\
    \x07\x04\x06\x03\0\x02\x06\x04\x12\x036\x10\x18\n\x0e\n\x07\x04\x06\x03\
    \0\x02\x06\x05\x12\x036\x19\x1e\n\x0e\n\x07\x04\x06\x03\0\x02\x06\x01\
    \x12\x036\x1f3\n\x0e\n\x07\x04\x06\x03\0\x02\x06\x03\x12\x03667\n\x0b\n\
    \x04\x04\x06\x02\0\x12\x039\x08\"\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\x17\n\x0c\n\x05\x04\
    \x06\x02\0\x01\x12\x039\x18\x1d\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x039\
    \x20!\n\x0b\n\x04\x04\x06\x02\x01\x12\x03:\x08$\n\x0c\n\x05\x04\x06\x02\
    \x01\x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03:\x11\
    \x17\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03:\x18\x1f\n\x0c\n\x05\x04\
    \x06\x02\x01\x03\x12\x03:\"#\n\x0b\n\x04\x04\x06\x02\x02\x12\x03;\x08P\n\
    \x0c\n\x05\x04\x06\x02\x02\x04\x12\x03;\x08\x10\n\x0c\n\x05\x04\x06\x02\
    \x02\x06\x12\x03;\x11C\n\x0c\n\x05\x04\x06\x02\x02\x01\x12\x03;DK\n\x0c\
    \n\x05\x04\x06\x02\x02\x03\x12\x03;NO\n\x0b\n\x04\x04\x06\x02\x03\x12\
    \x03<\x08&\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\n\n\x02\x04\
    \x07\x12\x04?\0B\x01\n\n\n\x03\x04\x07\x01\x12\x03?\x08*\n\x0b\n\x04\x04\
    \x07\x02\0\x12\x03@\x08\"\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03@\x08\x10\
    \n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03@\x11\x17\n\x0c\n\x05\x04\x07\x02\
    \0\x01\x12\x03@\x18\x1d\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03@\x20!\n\
    \x0b\n\x04\x04\x07\x02\x01\x12\x03A\x08&\n\x0c\n\x05\x04\x07\x02\x01\x04\
    \x12\x03A\x08\x10\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\x03A\x11\x17\n\x0c\
    \n\x05\x04\x07\x02\x01\x01\x12\x03A\x18!\n\x0c\n\x05\x04\x07\x02\x01\x03\
    \x12\x03A$%\n\n\n\x02\x04\x08\x12\x04D\0K\x01\n\n\n\x03\x04\x08\x01\x12\
    \x03D\x08&\n\x0b\n\x04\x04\x08\x02\0\x12\x03E\x08\"\n\x0c\n\x05\x04\x08\
    \x02\0\x04\x12\x03E\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03E\x11\
    \x17\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03E\x18\x1d\n\x0c\n\x05\x04\x08\
    \x02\0\x03\x12\x03E\x20!\n\x0b\n\x04\x04\x08\x02\x01\x12\x03F\x08#\n\x0c\
    \n\x05\x04\x08\x02\x01\x04\x12\x03F\x08\x10\n\x0c\n\x05\x04\x08\x02\x01\
    \x05\x12\x03F\x11\x17\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03F\x18\x1e\n\
    \x0c\n\x05\x04\x08\x02\x01\x03\x12\x03F!\"\n\x0b\n\x04\x04\x08\x02\x02\
    \x12\x03G\x08%\n\x0c\n\x05\x04\x08\x02\x02\x04\x12\x03G\x08\x10\n\x0c\n\
    \x05\x04\x08\x02\x02\x05\x12\x03G\x11\x17\n\x0c\n\x05\x04\x08\x02\x02\
    \x01\x12\x03G\x18\x20\n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x03G#$\n\x0b\n\
    \x04\x04\x08\x02\x03\x12\x03H\x08&\n\x0c\n\x05\x04\x08\x02\x03\x04\x12\
    \x03H\x08\x10\n\x0c\n\x05\x04\x08\x02\x03\x05\x12\x03H\x11\x17\n\x0c\n\
    \x05\x04\x08\x02\x03\x01\x12\x03H\x18!\n\x0c\n\x05\x04\x08\x02\x03\x03\
    \x12\x03H$%\n\x0b\n\x04\x04\x08\x02\x04\x12\x03I\x08$\n\x0c\n\x05\x04\
    \x08\x02\x04\x04\x12\x03I\x08\x10\n\x0c\n\x05\x04\x08\x02\x04\x05\x12\
    \x03I\x11\x17\n\x0c\n\x05\x04\x08\x02\x04\x01\x12\x03I\x18\x1f\n\x0c\n\
    \x05\x04\x08\x02\x04\x03\x12\x03I\"#\n\x0b\n\x04\x04\x08\x02\x05\x12\x03\
    J\x08&\n\x0c\n\x05\x04\x08\x02\x05\x04\x12\x03J\x08\x10\n\x0c\n\x05\x04\
    \x08\x02\x05\x05\x12\x03J\x11\x17\n\x0c\n\x05\x04\x08\x02\x05\x01\x12\
    \x03J\x18!\n\x0c\n\x05\x04\x08\x02\x05\x03\x12\x03J$%\n\n\n\x02\x04\t\
    \x12\x04M\0Q\x01\n\n\n\x03\x04\t\x01\x12\x03M\x08)\n\x0b\n\x04\x04\t\x02\
    \0\x12\x03N\x08\"\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03N\x08\x10\n\x0c\n\
    \x05\x04\t\x02\0\x05\x12\x03N\x11\x17\n\x0c\n\x05\x04\t\x02\0\x01\x12\
    \x03N\x18\x1d\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03N\x20!\n\x0b\n\x04\x04\
    \t\x02\x01\x12\x03O\x08&\n\x0c\n\x05\x04\t\x02\x01\x04\x12\x03O\x08\x10\
    \n\x0c\n\x05\x04\t\x02\x01\x05\x12\x03O\x11\x17\n\x0c\n\x05\x04\t\x02\
    \x01\x01\x12\x03O\x18!\n\x0c\n\x05\x04\t\x02\x01\x03\x12\x03O$%\n\x0b\n\
    \x04\x04\t\x02\x02\x12\x03P\x08%\n\x0c\n\x05\x04\t\x02\x02\x04\x12\x03P\
    \x08\x10\n\x0c\n\x05\x04\t\x02\x02\x05\x12\x03P\x11\x17\n\x0c\n\x05\x04\
    \t\x02\x02\x01\x12\x03P\x18\x20\n\x0c\n\x05\x04\t\x02\x02\x03\x12\x03P#$\
    \n\n\n\x02\x04\n\x12\x04S\0X\x01\n\n\n\x03\x04\n\x01\x12\x03S\x08)\n\x0b\
    \n\x04\x04\n\x02\0\x12\x03T\x08\"\n\x0c\n\x05\x04\n\x02\0\x04\x12\x03T\
    \x08\x10\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03T\x11\x17\n\x0c\n\x05\x04\n\
    \x02\0\x01\x12\x03T\x18\x1d\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03T\x20!\n\
    \x0b\n\x04\x04\n\x02\x01\x12\x03U\x08#\n\x0c\n\x05\x04\n\x02\x01\x04\x12\
    \x03U\x08\x10\n\x0c\n\x05\x04\n\x02\x01\x05\x12\x03U\x11\x17\n\x0c\n\x05\
    \x04\n\x02\x01\x01\x12\x03U\x18\x1e\n\x0c\n\x05\x04\n\x02\x01\x03\x12\
    \x03U!\"\n\x0b\n\x04\x04\n\x02\x02\x12\x03V\x08%\n\x0c\n\x05\x04\n\x02\
    \x02\x04\x12\x03V\x08\x10\n\x0c\n\x05\x04\n\x02\x02\x05\x12\x03V\x11\x17\
    \n\x0c\n\x05\x04\n\x02\x02\x01\x12\x03V\x18\x20\n\x0c\n\x05\x04\n\x02\
    \x02\x03\x12\x03V#$\n\x0b\n\x04\x04\n\x02\x03\x12\x03W\x08$\n\x0c\n\x05\
    \x04\n\x02\x03\x04\x12\x03W\x08\x10\n\x0c\n\x05\x04\n\x02\x03\x05\x12\
    \x03W\x11\x17\n\x0c\n\x05\x04\n\x02\x03\x01\x12\x03W\x18\x1f\n\x0c\n\x05\
    \x04\n\x02\x03\x03\x12\x03W\"#\n\n\n\x02\x04\x0b\x12\x04Z\0`\x01\n\n\n\
    \x03\x04\x0b\x01\x12\x03Z\x08,\n\x0b\n\x04\x04\x0b\x02\0\x12\x03[\x08\"\
    \n\x0c\n\x05\x04\x0b\x02\0\x04\x12\x03[\x08\x10\n\x0c\n\x05\x04\x0b\x02\
    \0\x05\x12\x03[\x11\x17\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03[\x18\x1d\n\
    \x0c\n\x05\x04\x0b\x02\0\x03\x12\x03[\x20!\n\x0b\n\x04\x04\x0b\x02\x01\
    \x12\x03\\\x08'\n\x0c\n\x05\x04\x0b\x02\x01\x04\x12\x03\\\x08\x10\n\x0c\
    \n\x05\x04\x0b\x02\x01\x05\x12\x03\\\x11\x17\n\x0c\n\x05\x04\x0b\x02\x01\
    \x01\x12\x03\\\x18\"\n\x0c\n\x05\x04\x0b\x02\x01\x03\x12\x03\\%&\n\x0b\n\
    \x04\x04\x0b\x02\x02\x12\x03]\x08'\n\x0c\n\x05\x04\x0b\x02\x02\x04\x12\
    \x03]\x08\x10\n\x0c\n\x05\x04\x0b\x02\x02\x05\x12\x03]\x11\x17\n\x0c\n\
    \x05\x04\x0b\x02\x02\x01\x12\x03]\x18\"\n\x0c\n\x05\x04\x0b\x02\x02\x03\
    \x12\x03]%&\n\x0b\n\x04\x04\x0b\x02\x03\x12\x03^\x08%\n\x0c\n\x05\x04\
    \x0b\x02\x03\x04\x12\x03^\x08\x10\n\x0c\n\x05\x04\x0b\x02\x03\x05\x12\
    \x03^\x11\x17\n\x0c\n\x05\x04\x0b\x02\x03\x01\x12\x03^\x18\x20\n\x0c\n\
    \x05\x04\x0b\x02\x03\x03\x12\x03^#$\n\x0b\n\x04\x04\x0b\x02\x04\x12\x03_\
    \x08%\n\x0c\n\x05\x04\x0b\x02\x04\x04\x12\x03_\x08\x10\n\x0c\n\x05\x04\
    \x0b\x02\x04\x05\x12\x03_\x11\x18\n\x0c\n\x05\x04\x0b\x02\x04\x01\x12\
    \x03_\x19\x20\n\x0c\n\x05\x04\x0b\x02\x04\x03\x12\x03_#$\n\n\n\x02\x04\
    \x0c\x12\x04b\0d\x01\n\n\n\x03\x04\x0c\x01\x12\x03b\x08)\n\x0b\n\x04\x04\
    \x0c\x02\0\x12\x03c\x08\"\n\x0c\n\x05\x04\x0c\x02\0\x04\x12\x03c\x08\x10\
    \n\x0c\n\x05\x04\x0c\x02\0\x05\x12\x03c\x11\x17\n\x0c\n\x05\x04\x0c\x02\
    \0\x01\x12\x03c\x18\x1d\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03c\x20!\n\n\
    \n\x02\x04\r\x12\x04f\0i\x01\n\n\n\x03\x04\r\x01\x12\x03f\x08*\n\x0b\n\
    \x04\x04\r\x02\0\x12\x03g\x08%\n\x0c\n\x05\x04\r\x02\0\x04\x12\x03g\x08\
    \x10\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03g\x11\x17\n\x0c\n\x05\x04\r\x02\
    \0\x01\x12\x03g\x18\x20\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03g#$\n\x0b\n\
    \x04\x04\r\x02\x01\x12\x03h\x08#\n\x0c\n\x05\x04\r\x02\x01\x04\x12\x03h\
    \x08\x10\n\x0c\n\x05\x04\r\x02\x01\x05\x12\x03h\x11\x17\n\x0c\n\x05\x04\
    \r\x02\x01\x01\x12\x03h\x18\x1e\n\x0c\n\x05\x04\r\x02\x01\x03\x12\x03h!\
    \"\n\n\n\x02\x04\x0e\x12\x04k\0l\x01\n\n\n\x03\x04\x0e\x01\x12\x03k\x08.\
    \n\n\n\x02\x04\x0f\x12\x04n\0p\x01\n\n\n\x03\x04\x0f\x01\x12\x03n\x08/\n\
    \x0b\n\x04\x04\x0f\x02\0\x12\x03o\x08%\n\x0c\n\x05\x04\x0f\x02\0\x04\x12\
    \x03o\x08\x10\n\x0c\n\x05\x04\x0f\x02\0\x05\x12\x03o\x11\x16\n\x0c\n\x05\
    \x04\x0f\x02\0\x01\x12\x03o\x17\x20\n\x0c\n\x05\x04\x0f\x02\0\x03\x12\
    \x03o#$\n\n\n\x02\x04\x10\x12\x04r\0{\x01\n\n\n\x03\x04\x10\x01\x12\x03r\
    \x08'\n\x0c\n\x04\x04\x10\x03\0\x12\x04s\x08v\t\n\x0c\n\x05\x04\x10\x03\
    \0\x01\x12\x03s\x10\x18\n\r\n\x06\x04\x10\x03\0\x02\0\x12\x03t\x10.\n\
    \x0e\n\x07\x04\x10\x03\0\x02\0\x04\x12\x03t\x10\x18\n\x0e\n\x07\x04\x10\
    \x03\0\x02\0\x05\x12\x03t\x19\x1f\n\x0e\n\x07\x04\x10\x03\0\x02\0\x01\
    \x12\x03t\x20)\n\x0e\n\x07\x04\x10\x03\0\x02\0\x03\x12\x03t,-\n\r\n\x06\
    \x04\x10\x03\0\x02\x01\x12\x03u\x10-\n\x0e\n\x07\x04\x10\x03\0\x02\x01\
    \x04\x12\x03u\x10\x18\n\x0e\n\x07\x04\x10\x03\0\x02\x01\x05\x12\x03u\x19\
    \x1f\n\x0e\n\x07\x04\x10\x03\0\x02\x01\x01\x12\x03u\x20(\n\x0e\n\x07\x04\
    \x10\x03\0\x02\x01\x03\x12\x03u+,\n\x0b\n\x04\x04\x10\x02\0\x12\x03x\x08\
    \"\n\x0c\n\x05\x04\x10\x02\0\x04\x12\x03x\x08\x10\n\x0c\n\x05\x04\x10\
    \x02\0\x05\x12\x03x\x11\x17\n\x0c\n\x05\x04\x10\x02\0\x01\x12\x03x\x18\
    \x1d\n\x0c\n\x05\x04\x10\x02\0\x03\x12\x03x\x20!\n\x0b\n\x04\x04\x10\x02\
    \x01\x12\x03y\x08$\n\x0c\n\x05\x04\x10\x02\x01\x04\x12\x03y\x08\x10\n\
    \x0c\n\x05\x04\x10\x02\x01\x05\x12\x03y\x11\x16\n\x0c\n\x05\x04\x10\x02\
    \x01\x01\x12\x03y\x17\x1f\n\x0c\n\x05\x04\x10\x02\x01\x03\x12\x03y\"#\n\
    \x0b\n\x04\x04\x10\x02\x02\x12\x03z\x08J\n\x0c\n\x05\x04\x10\x02\x02\x04\
    \x12\x03z\x08\x10\n\x0c\n\x05\x04\x10\x02\x02\x06\x12\x03z\x11:\n\x0c\n\
    \x05\x04\x10\x02\x02\x01\x12\x03z;E\n\x0c\n\x05\x04\x10\x02\x02\x03\x12\
    \x03zHI\n\x0b\n\x02\x04\x11\x12\x05}\0\x80\x01\x01\n\n\n\x03\x04\x11\x01\
    \x12\x03}\x08(\n\x0b\n\x04\x04\x11\x02\0\x12\x03~\x08$\n\x0c\n\x05\x04\
    \x11\x02\0\x04\x12\x03~\x08\x10\n\x0c\n\x05\x04\x11\x02\0\x05\x12\x03~\
    \x11\x17\n\x0c\n\x05\x04\x11\x02\0\x01\x12\x03~\x18\x1f\n\x0c\n\x05\x04\
    \x11\x02\0\x03\x12\x03~\"#\n\x0b\n\x04\x04\x11\x02\x01\x12\x03\x7f\x08$\
    \n\x0c\n\x05\x04\x11\x02\x01\x04\x12\x03\x7f\x08\x10\n\x0c\n\x05\x04\x11\
    \x02\x01\x05\x12\x03\x7f\x11\x17\n\x0c\n\x05\x04\x11\x02\x01\x01\x12\x03\
    \x7f\x18\x1f\n\x0c\n\x05\x04\x11\x02\x01\x03\x12\x03\x7f\"#\n\x0c\n\x02\
    \x04\x12\x12\x06\x82\x01\0\x86\x01\x01\n\x0b\n\x03\x04\x12\x01\x12\x04\
    \x82\x01\x08+\n\x0c\n\x04\x04\x12\x02\0\x12\x04\x83\x01\x08\"\n\r\n\x05\
    \x04\x12\x02\0\x04\x12\x04\x83\x01\x08\x10\n\r\n\x05\x04\x12\x02\0\x05\
    \x12\x04\x83\x01\x11\x17\n\r\n\x05\x04\x12\x02\0\x01\x12\x04\x83\x01\x18\
    \x1d\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\x83\x01\x20!\n\x0c\n\x04\x04\
    \x12\x02\x01\x12\x04\x84\x01\x08$\n\r\n\x05\x04\x12\x02\x01\x04\x12\x04\
    \x84\x01\x08\x10\n\r\n\x05\x04\x12\x02\x01\x05\x12\x04\x84\x01\x11\x16\n\
    \r\n\x05\x04\x12\x02\x01\x01\x12\x04\x84\x01\x17\x1f\n\r\n\x05\x04\x12\
    \x02\x01\x03\x12\x04\x84\x01\"#\n\x0c\n\x04\x04\x12\x02\x02\x12\x04\x85\
    \x01\x08$\n\r\n\x05\x04\x12\x02\x02\x04\x12\x04\x85\x01\x08\x10\n\r\n\
    \x05\x04\x12\x02\x02\x05\x12\x04\x85\x01\x11\x17\n\r\n\x05\x04\x12\x02\
    \x02\x01\x12\x04\x85\x01\x18\x1f\n\r\n\x05\x04\x12\x02\x02\x03\x12\x04\
    \x85\x01\"#\n\x0c\n\x02\x04\x13\x12\x06\x88\x01\0\x8c\x01\x01\n\x0b\n\
    \x03\x04\x13\x01\x12\x04\x88\x01\x08&\n\x0c\n\x04\x04\x13\x02\0\x12\x04\
    \x89\x01\x08&\n\r\n\x05\x04\x13\x02\0\x04\x12\x04\x89\x01\x08\x10\n\r\n\
    \x05\x04\x13\x02\0\x05\x12\x04\x89\x01\x11\x17\n\r\n\x05\x04\x13\x02\0\
    \x01\x12\x04\x89\x01\x18!\n\r\n\x05\x04\x13\x02\0\x03\x12\x04\x89\x01$%\
    \n\x0c\n\x04\x04\x13\x02\x01\x12\x04\x8a\x01\x08$\n\r\n\x05\x04\x13\x02\
    \x01\x04\x12\x04\x8a\x01\x08\x10\n\r\n\x05\x04\x13\x02\x01\x05\x12\x04\
    \x8a\x01\x11\x18\n\r\n\x05\x04\x13\x02\x01\x01\x12\x04\x8a\x01\x19\x1f\n\
    \r\n\x05\x04\x13\x02\x01\x03\x12\x04\x8a\x01\"#\n\x0c\n\x04\x04\x13\x02\
    \x02\x12\x04\x8b\x01\x08!\n\r\n\x05\x04\x13\x02\x02\x04\x12\x04\x8b\x01\
    \x08\x10\n\r\n\x05\x04\x13\x02\x02\x05\x12\x04\x8b\x01\x11\x17\n\r\n\x05\
    \x04\x13\x02\x02\x01\x12\x04\x8b\x01\x18\x1c\n\r\n\x05\x04\x13\x02\x02\
    \x03\x12\x04\x8b\x01\x1f\x20\n\x0c\n\x02\x04\x14\x12\x06\x8e\x01\0\x91\
    \x01\x01\n\x0b\n\x03\x04\x14\x01\x12\x04\x8e\x01\x08.\n\x0c\n\x04\x04\
    \x14\x02\0\x12\x04\x8f\x01\x08\"\n\r\n\x05\x04\x14\x02\0\x04\x12\x04\x8f\
    \x01\x08\x10\n\r\n\x05\x04\x14\x02\0\x05\x12\x04\x8f\x01\x11\x17\n\r\n\
    \x05\x04\x14\x02\0\x01\x12\x04\x8f\x01\x18\x1d\n\r\n\x05\x04\x14\x02\0\
    \x03\x12\x04\x8f\x01\x20!\n\x0c\n\x04\x04\x14\x02\x01\x12\x04\x90\x01\
    \x08=\n\r\n\x05\x04\x14\x02\x01\x04\x12\x04\x90\x01\x08\x10\n\r\n\x05\
    \x04\x14\x02\x01\x06\x12\x04\x90\x01\x11%\n\r\n\x05\x04\x14\x02\x01\x01\
    \x12\x04\x90\x01&8\n\r\n\x05\x04\x14\x02\x01\x03\x12\x04\x90\x01;<\n\x0c\
    \n\x02\x06\0\x12\x06\x93\x01\0\xd5\x01\x01\n\x0b\n\x03\x06\0\x01\x12\x04\
    \x93\x01\x08\x11\n\x0b\n\x03\x06\0\x03\x12\x04\x94\x01\x08U\n\x0e\n\x06\
    \x06\0\x03\xd0\x86\x03\x12\x04\x94\x01\x08U\n\x0e\n\x04\x06\0\x02\0\x12\
    \x06\x96\x01\x08\x98\x01\t\n\r\n\x05\x06\0\x02\0\x01\x12\x04\x96\x01\x0c\
    \x18\n\r\n\x05\x06\0\x02\0\x02\x12\x04\x96\x01\x1a:\n\r\n\x05\x06\0\x02\
    \0\x03\x12\x04\x96\x01EY\n\r\n\x05\x06\0\x02\0\x04\x12\x04\x97\x01\x10_\
    \n\x10\n\x08\x06\0\x02\0\x04\xd0\x86\x03\x12\x04\x97\x01\x10_\n\x0e\n\
    \x04\x06\0\x02\x01\x12\x06\x9a\x01\x08\x9c\x01\t\n\r\n\x05\x06\0\x02\x01\
    \x01\x12\x04\x9a\x01\x0c\x18\n\r\n\x05\x06\0\x02\x01\x02\x12\x04\x9a\x01\
    \x1a:\n\r\n\x05\x06\0\x02\x01\x03\x12\x04\x9a\x01EY\n\r\n\x05\x06\0\x02\
    \x01\x04\x12\x04\x9b\x01\x10T\n\x10\n\x08\x06\0\x02\x01\x04\xd0\x86\x03\
    \x12\x04\x9b\x01\x10T\n\x0e\n\x04\x06\0\x02\x02\x12\x06\x9e\x01\x08\xa0\
    \x01\t\n\r\n\x05\x06\0\x02\x02\x01\x12\x04\x9e\x01\x0c&\n\r\n\x05\x06\0\
    \x02\x02\x02\x12\x04\x9e\x01(V\n\x0e\n\x05\x06\0\x02\x02\x03\x12\x05\x9e\
    \x01a\x90\x01\n\r\n\x05\x06\0\x02\x02\x04\x12\x04\x9f\x01\x10k\n\x10\n\
    \x08\x06\0\x02\x02\x04\xd0\x86\x03\x12\x04\x9f\x01\x10k\n\x0e\n\x04\x06\
    \0\x02\x03\x12\x06\xa2\x01\x08\xa4\x01\t\n\r\n\x05\x06\0\x02\x03\x01\x12\
    \x04\xa2\x01\x0c\x18\n\r\n\x05\x06\0\x02\x03\x02\x12\x04\xa2\x01\x1a5\n\
    \r\n\x05\x06\0\x02\x03\x03\x12\x04\xa2\x01@T\n\r\n\x05\x06\0\x02\x03\x04\
    \x12\x04\xa3\x01\x10X\n\x10\n\x08\x06\0\x02\x03\x04\xd0\x86\x03\x12\x04\
    \xa3\x01\x10X\n\x0e\n\x04\x06\0\x02\x04\x12\x06\xa6\x01\x08\xa8\x01\t\n\
    \r\n\x05\x06\0\x02\x04\x01\x12\x04\xa6\x01\x0c\x1b\n\r\n\x05\x06\0\x02\
    \x04\x02\x12\x04\xa6\x01\x1d<\n\r\n\x05\x06\0\x02\x04\x03\x12\x04\xa6\
    \x01G[\n\r\n\x05\x06\0\x02\x04\x04\x12\x04\xa7\x01\x10l\n\x10\n\x08\x06\
    \0\x02\x04\x04\xd0\x86\x03\x12\x04\xa7\x01\x10l\n\x0e\n\x04\x06\0\x02\
    \x05\x12\x06\xaa\x01\x08\xac\x01\t\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\
    \xaa\x01\x0c\x1b\n\r\n\x05\x06\0\x02\x05\x02\x12\x04\xaa\x01\x1d@\n\r\n\
    \x05\x06\0\x02\x05\x03\x12\x04\xaa\x01K_\n\r\n\x05\x06\0\x02\x05\x04\x12\
    \x04\xab\x01\x10f\n\x10\n\x08\x06\0\x02\x05\x04\xd0\x86\x03\x12\x04\xab\
    \x01\x10f\n\x0e\n\x04\x06\0\x02\x06\x12\x06\xae\x01\x08\xb0\x01\t\n\r\n\
    \x05\x06\0\x02\x06\x01\x12\x04\xae\x01\x0c\x17\n\r\n\x05\x06\0\x02\x06\
    \x02\x12\x04\xae\x01\x198\n\r\n\x05\x06\0\x02\x06\x03\x12\x04\xae\x01CW\
    \n\r\n\x05\x06\0\x02\x06\x04\x12\x04\xaf\x01\x10@\n\x10\n\x08\x06\0\x02\
    \x06\x04\xd0\x86\x03\x12\x04\xaf\x01\x10@\n\x0e\n\x04\x06\0\x02\x07\x12\
    \x06\xb2\x01\x08\xb4\x01\t\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\xb2\x01\
    \x0c\x1b\n\r\n\x05\x06\0\x02\x07\x02\x12\x04\xb2\x01\x1d8\n\r\n\x05\x06\
    \0\x02\x07\x03\x12\x04\xb2\x01CW\n\r\n\x05\x06\0\x02\x07\x04\x12\x04\xb3\
    \x01\x10U\n\x10\n\x08\x06\0\x02\x07\x04\xd0\x86\x03\x12\x04\xb3\x01\x10U\
    \n\x0e\n\x04\x06\0\x02\x08\x12\x06\xb6\x01\x08\xb8\x01\t\n\r\n\x05\x06\0\
    \x02\x08\x01\x12\x04\xb6\x01\x0c\x1a\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\
    \xb6\x01\x1c>\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\xb6\x01I]\n\r\n\x05\
    \x06\0\x02\x08\x04\x12\x04\xb7\x01\x10@\n\x10\n\x08\x06\0\x02\x08\x04\
    \xd0\x86\x03\x12\x04\xb7\x01\x10@\n\x0e\n\x04\x06\0\x02\t\x12\x06\xba\
    \x01\x08\xbc\x01\t\n\r\n\x05\x06\0\x02\t\x01\x12\x04\xba\x01\x0c\x1a\n\r\
    \n\x05\x06\0\x02\t\x02\x12\x04\xba\x01\x1c>\n\r\n\x05\x06\0\x02\t\x03\
    \x12\x04\xba\x01I]\n\r\n\x05\x06\0\x02\t\x04\x12\x04\xbb\x01\x10T\n\x10\
    \n\x08\x06\0\x02\t\x04\xd0\x86\x03\x12\x04\xbb\x01\x10T\n\x0e\n\x04\x06\
    \0\x02\n\x12\x06\xbe\x01\x08\xc0\x01\t\n\r\n\x05\x06\0\x02\n\x01\x12\x04\
    \xbe\x01\x0c\x1d\n\r\n\x05\x06\0\x02\n\x02\x12\x04\xbe\x01\x1fD\n\r\n\
    \x05\x06\0\x02\n\x03\x12\x04\xbe\x01Oc\n\r\n\x05\x06\0\x02\n\x04\x12\x04\
    \xbf\x01\x10L\n\x10\n\x08\x06\0\x02\n\x04\xd0\x86\x03\x12\x04\xbf\x01\
    \x10L\n\x0e\n\x04\x06\0\x02\x0b\x12\x06\xc2\x01\x08\xc4\x01\t\n\r\n\x05\
    \x06\0\x02\x0b\x01\x12\x04\xc2\x01\x0c\x1a\n\r\n\x05\x06\0\x02\x0b\x02\
    \x12\x04\xc2\x01\x1c>\n\r\n\x05\x06\0\x02\x0b\x03\x12\x04\xc2\x01Il\n\r\
    \n\x05\x06\0\x02\x0b\x04\x12\x04\xc3\x01\x10n\n\x10\n\x08\x06\0\x02\x0b\
    \x04\xd0\x86\x03\x12\x04\xc3\x01\x10n\n\x0e\n\x04\x06\0\x02\x0c\x12\x06\
    \xc6\x01\x08\xc8\x01\t\n\r\n\x05\x06\0\x02\x0c\x01\x12\x04\xc6\x01\x0c\
    \x1f\n\r\n\x05\x06\0\x02\x0c\x02\x12\x04\xc6\x01!H\n\r\n\x05\x06\0\x02\
    \x0c\x03\x12\x04\xc6\x01S{\n\r\n\x05\x06\0\x02\x0c\x04\x12\x04\xc7\x01\
    \x10j\n\x10\n\x08\x06\0\x02\x0c\x04\xd0\x86\x03\x12\x04\xc7\x01\x10j\n\
    \x0e\n\x04\x06\0\x02\r\x12\x06\xca\x01\x08\xcc\x01\t\n\r\n\x05\x06\0\x02\
    \r\x01\x12\x04\xca\x01\x0c\x18\n\r\n\x05\x06\0\x02\r\x02\x12\x04\xca\x01\
    \x1a:\n\r\n\x05\x06\0\x02\r\x03\x12\x04\xca\x01Ef\n\r\n\x05\x06\0\x02\r\
    \x04\x12\x04\xcb\x01\x10T\n\x10\n\x08\x06\0\x02\r\x04\xd0\x86\x03\x12\
    \x04\xcb\x01\x10T\n\x0e\n\x04\x06\0\x02\x0e\x12\x06\xce\x01\x08\xd0\x01\
    \t\n\r\n\x05\x06\0\x02\x0e\x01\x12\x04\xce\x01\x0c\x1c\n\r\n\x05\x06\0\
    \x02\x0e\x02\x12\x04\xce\x01\x1eB\n\r\n\x05\x06\0\x02\x0e\x03\x12\x04\
    \xce\x01Ma\n\r\n\x05\x06\0\x02\x0e\x04\x12\x04\xcf\x01\x10R\n\x10\n\x08\
    \x06\0\x02\x0e\x04\xd0\x86\x03\x12\x04\xcf\x01\x10R\n\x0e\n\x04\x06\0\
    \x02\x0f\x12\x06\xd2\x01\x08\xd4\x01\t\n\r\n\x05\x06\0\x02\x0f\x01\x12\
    \x04\xd2\x01\x0c\x17\n\r\n\x05\x06\0\x02\x0f\x02\x12\x04\xd2\x01\x198\n\
    \r\n\x05\x06\0\x02\x0f\x03\x12\x04\xd2\x01CW\n\r\n\x05\x06\0\x02\x0f\x04\
    \x12\x04\xd3\x01\x10_\n\x10\n\x08\x06\0\x02\x0f\x04\xd0\x86\x03\x12\x04\
    \xd3\x01\x10_\n\x0c\n\x02\x06\x01\x12\x06\xd7\x01\0\xde\x01\x01\n\x0b\n\
    \x03\x06\x01\x01\x12\x04\xd7\x01\x08\x17\n\x0b\n\x03\x06\x01\x03\x12\x04\
    \xd8\x01\x08W\n\x0e\n\x06\x06\x01\x03\xd0\x86\x03\x12\x04\xd8\x01\x08W\n\
    \x0b\n\x03\x06\x01\x03\x12\x04\xd9\x01\x08K\n\x0e\n\x06\x06\x01\x03\xd8\
    \x86\x03\x12\x04\xd9\x01\x08K\n\x0e\n\x04\x06\x01\x02\0\x12\x06\xdb\x01\
    \x08\xdd\x01\t\n\r\n\x05\x06\x01\x02\0\x01\x12\x04\xdb\x01\x0c\x1a\n\r\n\
    \x05\x06\x01\x02\0\x02\x12\x04\xdb\x01\x1cC\n\r\n\x05\x06\x01\x02\0\x03\
    \x12\x04\xdb\x01NY\n\r\n\x05\x06\x01\x02\0\x04\x12\x04\xdc\x01\x10_\n\
    \x10\n\x08\x06\x01\x02\0\x04\xd0\x86\x03\x12\x04\xdc\x01\x10_\
";

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