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_virtualcontroller.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 CVirtualControllerElement {
    // message fields
    field_type: ::std::option::Option<EControllerElementType>,
    visible: ::std::option::Option<bool>,
    x_position: ::std::option::Option<f32>,
    y_position: ::std::option::Option<f32>,
    x_scale: ::std::option::Option<f32>,
    y_scale: ::std::option::Option<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .EControllerElementType type = 1;


    pub fn get_field_type(&self) -> EControllerElementType {
        self.field_type.unwrap_or(EControllerElementType::k_EControllerElementTypeNone)
    }
    pub fn clear_field_type(&mut self) {
        self.field_type = ::std::option::Option::None;
    }

    pub fn has_field_type(&self) -> bool {
        self.field_type.is_some()
    }

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

    // optional bool visible = 2;


    pub fn get_visible(&self) -> bool {
        self.visible.unwrap_or(false)
    }
    pub fn clear_visible(&mut self) {
        self.visible = ::std::option::Option::None;
    }

    pub fn has_visible(&self) -> bool {
        self.visible.is_some()
    }

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

    // optional float x_position = 3;


    pub fn get_x_position(&self) -> f32 {
        self.x_position.unwrap_or(0.)
    }
    pub fn clear_x_position(&mut self) {
        self.x_position = ::std::option::Option::None;
    }

    pub fn has_x_position(&self) -> bool {
        self.x_position.is_some()
    }

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

    // optional float y_position = 4;


    pub fn get_y_position(&self) -> f32 {
        self.y_position.unwrap_or(0.)
    }
    pub fn clear_y_position(&mut self) {
        self.y_position = ::std::option::Option::None;
    }

    pub fn has_y_position(&self) -> bool {
        self.y_position.is_some()
    }

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

    // optional float x_scale = 5;


    pub fn get_x_scale(&self) -> f32 {
        self.x_scale.unwrap_or(1.0f32)
    }
    pub fn clear_x_scale(&mut self) {
        self.x_scale = ::std::option::Option::None;
    }

    pub fn has_x_scale(&self) -> bool {
        self.x_scale.is_some()
    }

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

    // optional float y_scale = 6;


    pub fn get_y_scale(&self) -> f32 {
        self.y_scale.unwrap_or(1.0f32)
    }
    pub fn clear_y_scale(&mut self) {
        self.y_scale = ::std::option::Option::None;
    }

    pub fn has_y_scale(&self) -> bool {
        self.y_scale.is_some()
    }

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

impl ::protobuf::Message for CVirtualControllerElement {
    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_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 1, &mut self.unknown_fields)?
                },
                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.visible = ::std::option::Option::Some(tmp);
                },
                3 => {
                    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.x_position = ::std::option::Option::Some(tmp);
                },
                4 => {
                    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.y_position = ::std::option::Option::Some(tmp);
                },
                5 => {
                    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.x_scale = ::std::option::Option::Some(tmp);
                },
                6 => {
                    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.y_scale = ::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.field_type {
            my_size += ::protobuf::rt::enum_size(1, v);
        }
        if let Some(v) = self.visible {
            my_size += 2;
        }
        if let Some(v) = self.x_position {
            my_size += 5;
        }
        if let Some(v) = self.y_position {
            my_size += 5;
        }
        if let Some(v) = self.x_scale {
            my_size += 5;
        }
        if let Some(v) = self.y_scale {
            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.field_type {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.visible {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.x_position {
            os.write_float(3, v)?;
        }
        if let Some(v) = self.y_position {
            os.write_float(4, v)?;
        }
        if let Some(v) = self.x_scale {
            os.write_float(5, v)?;
        }
        if let Some(v) = self.y_scale {
            os.write_float(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() -> CVirtualControllerElement {
        CVirtualControllerElement::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::ProtobufTypeEnum<EControllerElementType>>(
                "type",
                |m: &CVirtualControllerElement| { &m.field_type },
                |m: &mut CVirtualControllerElement| { &mut m.field_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "visible",
                |m: &CVirtualControllerElement| { &m.visible },
                |m: &mut CVirtualControllerElement| { &mut m.visible },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "x_position",
                |m: &CVirtualControllerElement| { &m.x_position },
                |m: &mut CVirtualControllerElement| { &mut m.x_position },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "y_position",
                |m: &CVirtualControllerElement| { &m.y_position },
                |m: &mut CVirtualControllerElement| { &mut m.y_position },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "x_scale",
                |m: &CVirtualControllerElement| { &m.x_scale },
                |m: &mut CVirtualControllerElement| { &mut m.x_scale },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "y_scale",
                |m: &CVirtualControllerElement| { &m.y_scale },
                |m: &mut CVirtualControllerElement| { &mut m.y_scale },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerElement>(
                "CVirtualControllerElement",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerElement {
    fn clear(&mut self) {
        self.field_type = ::std::option::Option::None;
        self.visible = ::std::option::Option::None;
        self.x_position = ::std::option::Option::None;
        self.y_position = ::std::option::Option::None;
        self.x_scale = ::std::option::Option::None;
        self.y_scale = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerColor {
    // message fields
    r: ::std::option::Option<f32>,
    g: ::std::option::Option<f32>,
    b: ::std::option::Option<f32>,
    a: ::std::option::Option<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional float r = 1;


    pub fn get_r(&self) -> f32 {
        self.r.unwrap_or(1.0f32)
    }
    pub fn clear_r(&mut self) {
        self.r = ::std::option::Option::None;
    }

    pub fn has_r(&self) -> bool {
        self.r.is_some()
    }

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

    // optional float g = 2;


    pub fn get_g(&self) -> f32 {
        self.g.unwrap_or(1.0f32)
    }
    pub fn clear_g(&mut self) {
        self.g = ::std::option::Option::None;
    }

    pub fn has_g(&self) -> bool {
        self.g.is_some()
    }

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

    // optional float b = 3;


    pub fn get_b(&self) -> f32 {
        self.b.unwrap_or(1.0f32)
    }
    pub fn clear_b(&mut self) {
        self.b = ::std::option::Option::None;
    }

    pub fn has_b(&self) -> bool {
        self.b.is_some()
    }

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

    // optional float a = 4;


    pub fn get_a(&self) -> f32 {
        self.a.unwrap_or(1.0f32)
    }
    pub fn clear_a(&mut self) {
        self.a = ::std::option::Option::None;
    }

    pub fn has_a(&self) -> bool {
        self.a.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_float()?;
                    self.r = ::std::option::Option::Some(tmp);
                },
                2 => {
                    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.g = ::std::option::Option::Some(tmp);
                },
                3 => {
                    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.b = ::std::option::Option::Some(tmp);
                },
                4 => {
                    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.a = ::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.r {
            my_size += 5;
        }
        if let Some(v) = self.g {
            my_size += 5;
        }
        if let Some(v) = self.b {
            my_size += 5;
        }
        if let Some(v) = self.a {
            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.r {
            os.write_float(1, v)?;
        }
        if let Some(v) = self.g {
            os.write_float(2, v)?;
        }
        if let Some(v) = self.b {
            os.write_float(3, v)?;
        }
        if let Some(v) = self.a {
            os.write_float(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() -> CVirtualControllerColor {
        CVirtualControllerColor::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::ProtobufTypeFloat>(
                "r",
                |m: &CVirtualControllerColor| { &m.r },
                |m: &mut CVirtualControllerColor| { &mut m.r },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "g",
                |m: &CVirtualControllerColor| { &m.g },
                |m: &mut CVirtualControllerColor| { &mut m.g },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "b",
                |m: &CVirtualControllerColor| { &m.b },
                |m: &mut CVirtualControllerColor| { &mut m.b },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "a",
                |m: &CVirtualControllerColor| { &m.a },
                |m: &mut CVirtualControllerColor| { &mut m.a },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerColor>(
                "CVirtualControllerColor",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerColor {
    fn clear(&mut self) {
        self.r = ::std::option::Option::None;
        self.g = ::std::option::Option::None;
        self.b = ::std::option::Option::None;
        self.a = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerLayout {
    // message fields
    layout_version: ::std::option::Option<i32>,
    actionset_id: ::std::option::Option<i32>,
    pub elements: ::protobuf::RepeatedField<CVirtualControllerElement>,
    pub color: ::protobuf::SingularPtrField<CVirtualControllerColor>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 layout_version = 1;


    pub fn get_layout_version(&self) -> i32 {
        self.layout_version.unwrap_or(0)
    }
    pub fn clear_layout_version(&mut self) {
        self.layout_version = ::std::option::Option::None;
    }

    pub fn has_layout_version(&self) -> bool {
        self.layout_version.is_some()
    }

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

    // optional int32 actionset_id = 2;


    pub fn get_actionset_id(&self) -> i32 {
        self.actionset_id.unwrap_or(0)
    }
    pub fn clear_actionset_id(&mut self) {
        self.actionset_id = ::std::option::Option::None;
    }

    pub fn has_actionset_id(&self) -> bool {
        self.actionset_id.is_some()
    }

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

    // repeated .CVirtualControllerElement elements = 4;


    pub fn get_elements(&self) -> &[CVirtualControllerElement] {
        &self.elements
    }
    pub fn clear_elements(&mut self) {
        self.elements.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_elements(&mut self) -> &mut ::protobuf::RepeatedField<CVirtualControllerElement> {
        &mut self.elements
    }

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

    // optional .CVirtualControllerColor color = 5;


    pub fn get_color(&self) -> &CVirtualControllerColor {
        self.color.as_ref().unwrap_or_else(|| <CVirtualControllerColor as ::protobuf::Message>::default_instance())
    }
    pub fn clear_color(&mut self) {
        self.color.clear();
    }

    pub fn has_color(&self) -> bool {
        self.color.is_some()
    }

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

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

    // Take field
    pub fn take_color(&mut self) -> CVirtualControllerColor {
        self.color.take().unwrap_or_else(|| CVirtualControllerColor::new())
    }
}

impl ::protobuf::Message for CVirtualControllerLayout {
    fn is_initialized(&self) -> bool {
        for v in &self.elements {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.color {
            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_int32()?;
                    self.layout_version = ::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.actionset_id = ::std::option::Option::Some(tmp);
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.elements)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.color)?;
                },
                _ => {
                    ::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.layout_version {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.actionset_id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.elements {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.color.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.layout_version {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.actionset_id {
            os.write_int32(2, v)?;
        }
        for v in &self.elements {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.color.as_ref() {
            os.write_tag(5, ::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() -> CVirtualControllerLayout {
        CVirtualControllerLayout::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>(
                "layout_version",
                |m: &CVirtualControllerLayout| { &m.layout_version },
                |m: &mut CVirtualControllerLayout| { &mut m.layout_version },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "actionset_id",
                |m: &CVirtualControllerLayout| { &m.actionset_id },
                |m: &mut CVirtualControllerLayout| { &mut m.actionset_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerElement>>(
                "elements",
                |m: &CVirtualControllerLayout| { &m.elements },
                |m: &mut CVirtualControllerLayout| { &mut m.elements },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerColor>>(
                "color",
                |m: &CVirtualControllerLayout| { &m.color },
                |m: &mut CVirtualControllerLayout| { &mut m.color },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerLayout>(
                "CVirtualControllerLayout",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerLayout {
    fn clear(&mut self) {
        self.layout_version = ::std::option::Option::None;
        self.actionset_id = ::std::option::Option::None;
        self.elements.clear();
        self.color.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerLayouts {
    // message fields
    pub layouts: ::protobuf::RepeatedField<CVirtualControllerLayout>,
    input_mode: ::std::option::Option<EInputMode>,
    mouse_mode: ::std::option::Option<EMouseMode>,
    trackpad_sensitivity: ::std::option::Option<f32>,
    pinch_zoom_enabled: ::std::option::Option<bool>,
    pinch_zoom_x: ::std::option::Option<f32>,
    pinch_zoom_y: ::std::option::Option<f32>,
    pinch_zoom_scale: ::std::option::Option<f32>,
    shaken: ::std::option::Option<bool>,
    mouse_offscreen: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .CVirtualControllerLayout layouts = 1;


    pub fn get_layouts(&self) -> &[CVirtualControllerLayout] {
        &self.layouts
    }
    pub fn clear_layouts(&mut self) {
        self.layouts.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_layouts(&mut self) -> &mut ::protobuf::RepeatedField<CVirtualControllerLayout> {
        &mut self.layouts
    }

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

    // optional .EInputMode input_mode = 2;


    pub fn get_input_mode(&self) -> EInputMode {
        self.input_mode.unwrap_or(EInputMode::k_EInputModeController)
    }
    pub fn clear_input_mode(&mut self) {
        self.input_mode = ::std::option::Option::None;
    }

    pub fn has_input_mode(&self) -> bool {
        self.input_mode.is_some()
    }

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

    // optional .EMouseMode mouse_mode = 3;


    pub fn get_mouse_mode(&self) -> EMouseMode {
        self.mouse_mode.unwrap_or(EMouseMode::k_EMouseModeUnknown)
    }
    pub fn clear_mouse_mode(&mut self) {
        self.mouse_mode = ::std::option::Option::None;
    }

    pub fn has_mouse_mode(&self) -> bool {
        self.mouse_mode.is_some()
    }

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

    // optional float trackpad_sensitivity = 4;


    pub fn get_trackpad_sensitivity(&self) -> f32 {
        self.trackpad_sensitivity.unwrap_or(1.0f32)
    }
    pub fn clear_trackpad_sensitivity(&mut self) {
        self.trackpad_sensitivity = ::std::option::Option::None;
    }

    pub fn has_trackpad_sensitivity(&self) -> bool {
        self.trackpad_sensitivity.is_some()
    }

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

    // optional bool pinch_zoom_enabled = 5;


    pub fn get_pinch_zoom_enabled(&self) -> bool {
        self.pinch_zoom_enabled.unwrap_or(false)
    }
    pub fn clear_pinch_zoom_enabled(&mut self) {
        self.pinch_zoom_enabled = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_enabled(&self) -> bool {
        self.pinch_zoom_enabled.is_some()
    }

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

    // optional float pinch_zoom_x = 6;


    pub fn get_pinch_zoom_x(&self) -> f32 {
        self.pinch_zoom_x.unwrap_or(0.0f32)
    }
    pub fn clear_pinch_zoom_x(&mut self) {
        self.pinch_zoom_x = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_x(&self) -> bool {
        self.pinch_zoom_x.is_some()
    }

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

    // optional float pinch_zoom_y = 7;


    pub fn get_pinch_zoom_y(&self) -> f32 {
        self.pinch_zoom_y.unwrap_or(0.0f32)
    }
    pub fn clear_pinch_zoom_y(&mut self) {
        self.pinch_zoom_y = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_y(&self) -> bool {
        self.pinch_zoom_y.is_some()
    }

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

    // optional float pinch_zoom_scale = 8;


    pub fn get_pinch_zoom_scale(&self) -> f32 {
        self.pinch_zoom_scale.unwrap_or(1.0f32)
    }
    pub fn clear_pinch_zoom_scale(&mut self) {
        self.pinch_zoom_scale = ::std::option::Option::None;
    }

    pub fn has_pinch_zoom_scale(&self) -> bool {
        self.pinch_zoom_scale.is_some()
    }

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

    // optional bool shaken = 9;


    pub fn get_shaken(&self) -> bool {
        self.shaken.unwrap_or(false)
    }
    pub fn clear_shaken(&mut self) {
        self.shaken = ::std::option::Option::None;
    }

    pub fn has_shaken(&self) -> bool {
        self.shaken.is_some()
    }

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

    // optional bool mouse_offscreen = 10;


    pub fn get_mouse_offscreen(&self) -> bool {
        self.mouse_offscreen.unwrap_or(false)
    }
    pub fn clear_mouse_offscreen(&mut self) {
        self.mouse_offscreen = ::std::option::Option::None;
    }

    pub fn has_mouse_offscreen(&self) -> bool {
        self.mouse_offscreen.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.layouts)?;
                },
                2 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.input_mode, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.mouse_mode, 3, &mut self.unknown_fields)?
                },
                4 => {
                    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.trackpad_sensitivity = ::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.pinch_zoom_enabled = ::std::option::Option::Some(tmp);
                },
                6 => {
                    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.pinch_zoom_x = ::std::option::Option::Some(tmp);
                },
                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.pinch_zoom_y = ::std::option::Option::Some(tmp);
                },
                8 => {
                    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.pinch_zoom_scale = ::std::option::Option::Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.shaken = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.mouse_offscreen = ::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;
        for value in &self.layouts {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.input_mode {
            my_size += ::protobuf::rt::enum_size(2, v);
        }
        if let Some(v) = self.mouse_mode {
            my_size += ::protobuf::rt::enum_size(3, v);
        }
        if let Some(v) = self.trackpad_sensitivity {
            my_size += 5;
        }
        if let Some(v) = self.pinch_zoom_enabled {
            my_size += 2;
        }
        if let Some(v) = self.pinch_zoom_x {
            my_size += 5;
        }
        if let Some(v) = self.pinch_zoom_y {
            my_size += 5;
        }
        if let Some(v) = self.pinch_zoom_scale {
            my_size += 5;
        }
        if let Some(v) = self.shaken {
            my_size += 2;
        }
        if let Some(v) = self.mouse_offscreen {
            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<()> {
        for v in &self.layouts {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.input_mode {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.mouse_mode {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(v) = self.trackpad_sensitivity {
            os.write_float(4, v)?;
        }
        if let Some(v) = self.pinch_zoom_enabled {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.pinch_zoom_x {
            os.write_float(6, v)?;
        }
        if let Some(v) = self.pinch_zoom_y {
            os.write_float(7, v)?;
        }
        if let Some(v) = self.pinch_zoom_scale {
            os.write_float(8, v)?;
        }
        if let Some(v) = self.shaken {
            os.write_bool(9, v)?;
        }
        if let Some(v) = self.mouse_offscreen {
            os.write_bool(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerLayout>>(
                "layouts",
                |m: &CVirtualControllerLayouts| { &m.layouts },
                |m: &mut CVirtualControllerLayouts| { &mut m.layouts },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EInputMode>>(
                "input_mode",
                |m: &CVirtualControllerLayouts| { &m.input_mode },
                |m: &mut CVirtualControllerLayouts| { &mut m.input_mode },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EMouseMode>>(
                "mouse_mode",
                |m: &CVirtualControllerLayouts| { &m.mouse_mode },
                |m: &mut CVirtualControllerLayouts| { &mut m.mouse_mode },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "trackpad_sensitivity",
                |m: &CVirtualControllerLayouts| { &m.trackpad_sensitivity },
                |m: &mut CVirtualControllerLayouts| { &mut m.trackpad_sensitivity },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "pinch_zoom_enabled",
                |m: &CVirtualControllerLayouts| { &m.pinch_zoom_enabled },
                |m: &mut CVirtualControllerLayouts| { &mut m.pinch_zoom_enabled },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "pinch_zoom_x",
                |m: &CVirtualControllerLayouts| { &m.pinch_zoom_x },
                |m: &mut CVirtualControllerLayouts| { &mut m.pinch_zoom_x },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "pinch_zoom_y",
                |m: &CVirtualControllerLayouts| { &m.pinch_zoom_y },
                |m: &mut CVirtualControllerLayouts| { &mut m.pinch_zoom_y },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                "pinch_zoom_scale",
                |m: &CVirtualControllerLayouts| { &m.pinch_zoom_scale },
                |m: &mut CVirtualControllerLayouts| { &mut m.pinch_zoom_scale },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "shaken",
                |m: &CVirtualControllerLayouts| { &m.shaken },
                |m: &mut CVirtualControllerLayouts| { &mut m.shaken },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "mouse_offscreen",
                |m: &CVirtualControllerLayouts| { &m.mouse_offscreen },
                |m: &mut CVirtualControllerLayouts| { &mut m.mouse_offscreen },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerLayouts>(
                "CVirtualControllerLayouts",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerLayouts {
    fn clear(&mut self) {
        self.layouts.clear();
        self.input_mode = ::std::option::Option::None;
        self.mouse_mode = ::std::option::Option::None;
        self.trackpad_sensitivity = ::std::option::Option::None;
        self.pinch_zoom_enabled = ::std::option::Option::None;
        self.pinch_zoom_x = ::std::option::Option::None;
        self.pinch_zoom_y = ::std::option::Option::None;
        self.pinch_zoom_scale = ::std::option::Option::None;
        self.shaken = ::std::option::Option::None;
        self.mouse_offscreen = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerConfig {
    // message fields
    name: ::protobuf::SingularField<::std::string::String>,
    pub actionsets: ::protobuf::RepeatedField<CVirtualControllerConfig_ActionSet>,
    default_mouse_mode: ::std::option::Option<EMouseMode>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string name = 1;


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

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

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

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

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

    // repeated .CVirtualControllerConfig.ActionSet actionsets = 2;


    pub fn get_actionsets(&self) -> &[CVirtualControllerConfig_ActionSet] {
        &self.actionsets
    }
    pub fn clear_actionsets(&mut self) {
        self.actionsets.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_actionsets(&mut self) -> &mut ::protobuf::RepeatedField<CVirtualControllerConfig_ActionSet> {
        &mut self.actionsets
    }

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

    // optional .EMouseMode default_mouse_mode = 3;


    pub fn get_default_mouse_mode(&self) -> EMouseMode {
        self.default_mouse_mode.unwrap_or(EMouseMode::k_EMouseModeRelative)
    }
    pub fn clear_default_mouse_mode(&mut self) {
        self.default_mouse_mode = ::std::option::Option::None;
    }

    pub fn has_default_mouse_mode(&self) -> bool {
        self.default_mouse_mode.is_some()
    }

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

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        for value in &self.actionsets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.default_mouse_mode {
            my_size += ::protobuf::rt::enum_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(ref v) = self.name.as_ref() {
            os.write_string(1, &v)?;
        }
        for v in &self.actionsets {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.default_mouse_mode {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&v))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CVirtualControllerConfig| { &m.name },
                |m: &mut CVirtualControllerConfig| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerConfig_ActionSet>>(
                "actionsets",
                |m: &CVirtualControllerConfig| { &m.actionsets },
                |m: &mut CVirtualControllerConfig| { &mut m.actionsets },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EMouseMode>>(
                "default_mouse_mode",
                |m: &CVirtualControllerConfig| { &m.default_mouse_mode },
                |m: &mut CVirtualControllerConfig| { &mut m.default_mouse_mode },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerConfig>(
                "CVirtualControllerConfig",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerConfig {
    fn clear(&mut self) {
        self.name.clear();
        self.actionsets.clear();
        self.default_mouse_mode = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerConfig_Control {
    // message fields
    name: ::protobuf::SingularField<::std::string::String>,
    icon: ::protobuf::SingularField<::std::string::String>,
    input_source: ::std::option::Option<i32>,
    input_mode: ::std::option::Option<i32>,
    input_element: ::std::option::Option<i32>,
    output_gamepad: ::std::option::Option<i32>,
    output_keyboard: ::std::option::Option<i32>,
    output_mouse: ::std::option::Option<i32>,
    icon_foreground: ::protobuf::SingularField<::std::string::String>,
    icon_background: ::protobuf::SingularField<::std::string::String>,
    input_toggle: ::std::option::Option<bool>,
    input_activate_stick_or_trackpad: ::std::option::Option<i32>,
    activation_type: ::std::option::Option<i32>,
    long_press_ms: ::std::option::Option<i32>,
    double_press_ms: ::std::option::Option<i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string name = 1;


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

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

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

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

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

    // optional string icon = 2;


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

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

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

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

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

    // optional int32 input_source = 3;


    pub fn get_input_source(&self) -> i32 {
        self.input_source.unwrap_or(0)
    }
    pub fn clear_input_source(&mut self) {
        self.input_source = ::std::option::Option::None;
    }

    pub fn has_input_source(&self) -> bool {
        self.input_source.is_some()
    }

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

    // optional int32 input_mode = 4;


    pub fn get_input_mode(&self) -> i32 {
        self.input_mode.unwrap_or(0)
    }
    pub fn clear_input_mode(&mut self) {
        self.input_mode = ::std::option::Option::None;
    }

    pub fn has_input_mode(&self) -> bool {
        self.input_mode.is_some()
    }

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

    // optional int32 input_element = 5;


    pub fn get_input_element(&self) -> i32 {
        self.input_element.unwrap_or(0)
    }
    pub fn clear_input_element(&mut self) {
        self.input_element = ::std::option::Option::None;
    }

    pub fn has_input_element(&self) -> bool {
        self.input_element.is_some()
    }

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

    // optional int32 output_gamepad = 6;


    pub fn get_output_gamepad(&self) -> i32 {
        self.output_gamepad.unwrap_or(0)
    }
    pub fn clear_output_gamepad(&mut self) {
        self.output_gamepad = ::std::option::Option::None;
    }

    pub fn has_output_gamepad(&self) -> bool {
        self.output_gamepad.is_some()
    }

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

    // optional int32 output_keyboard = 7;


    pub fn get_output_keyboard(&self) -> i32 {
        self.output_keyboard.unwrap_or(0)
    }
    pub fn clear_output_keyboard(&mut self) {
        self.output_keyboard = ::std::option::Option::None;
    }

    pub fn has_output_keyboard(&self) -> bool {
        self.output_keyboard.is_some()
    }

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

    // optional int32 output_mouse = 8;


    pub fn get_output_mouse(&self) -> i32 {
        self.output_mouse.unwrap_or(0)
    }
    pub fn clear_output_mouse(&mut self) {
        self.output_mouse = ::std::option::Option::None;
    }

    pub fn has_output_mouse(&self) -> bool {
        self.output_mouse.is_some()
    }

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

    // optional string icon_foreground = 9;


    pub fn get_icon_foreground(&self) -> &str {
        match self.icon_foreground.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_icon_foreground(&mut self) {
        self.icon_foreground.clear();
    }

    pub fn has_icon_foreground(&self) -> bool {
        self.icon_foreground.is_some()
    }

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

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

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

    // optional string icon_background = 10;


    pub fn get_icon_background(&self) -> &str {
        match self.icon_background.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_icon_background(&mut self) {
        self.icon_background.clear();
    }

    pub fn has_icon_background(&self) -> bool {
        self.icon_background.is_some()
    }

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

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

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

    // optional bool input_toggle = 11;


    pub fn get_input_toggle(&self) -> bool {
        self.input_toggle.unwrap_or(false)
    }
    pub fn clear_input_toggle(&mut self) {
        self.input_toggle = ::std::option::Option::None;
    }

    pub fn has_input_toggle(&self) -> bool {
        self.input_toggle.is_some()
    }

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

    // optional int32 input_activate_stick_or_trackpad = 12;


    pub fn get_input_activate_stick_or_trackpad(&self) -> i32 {
        self.input_activate_stick_or_trackpad.unwrap_or(0)
    }
    pub fn clear_input_activate_stick_or_trackpad(&mut self) {
        self.input_activate_stick_or_trackpad = ::std::option::Option::None;
    }

    pub fn has_input_activate_stick_or_trackpad(&self) -> bool {
        self.input_activate_stick_or_trackpad.is_some()
    }

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

    // optional int32 activation_type = 13;


    pub fn get_activation_type(&self) -> i32 {
        self.activation_type.unwrap_or(0)
    }
    pub fn clear_activation_type(&mut self) {
        self.activation_type = ::std::option::Option::None;
    }

    pub fn has_activation_type(&self) -> bool {
        self.activation_type.is_some()
    }

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

    // optional int32 long_press_ms = 14;


    pub fn get_long_press_ms(&self) -> i32 {
        self.long_press_ms.unwrap_or(0)
    }
    pub fn clear_long_press_ms(&mut self) {
        self.long_press_ms = ::std::option::Option::None;
    }

    pub fn has_long_press_ms(&self) -> bool {
        self.long_press_ms.is_some()
    }

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

    // optional int32 double_press_ms = 15;


    pub fn get_double_press_ms(&self) -> i32 {
        self.double_press_ms.unwrap_or(0)
    }
    pub fn clear_double_press_ms(&mut self) {
        self.double_press_ms = ::std::option::Option::None;
    }

    pub fn has_double_press_ms(&self) -> bool {
        self.double_press_ms.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.icon)?;
                },
                3 => {
                    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.input_source = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.input_mode = ::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_int32()?;
                    self.input_element = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.output_gamepad = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.output_keyboard = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.output_mouse = ::std::option::Option::Some(tmp);
                },
                9 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.icon_foreground)?;
                },
                10 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.icon_background)?;
                },
                11 => {
                    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.input_toggle = ::std::option::Option::Some(tmp);
                },
                12 => {
                    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.input_activate_stick_or_trackpad = ::std::option::Option::Some(tmp);
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.activation_type = ::std::option::Option::Some(tmp);
                },
                14 => {
                    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.long_press_ms = ::std::option::Option::Some(tmp);
                },
                15 => {
                    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.double_press_ms = ::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.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.icon.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.input_source {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.input_mode {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.input_element {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.output_gamepad {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.output_keyboard {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.output_mouse {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.icon_foreground.as_ref() {
            my_size += ::protobuf::rt::string_size(9, &v);
        }
        if let Some(ref v) = self.icon_background.as_ref() {
            my_size += ::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.input_toggle {
            my_size += 2;
        }
        if let Some(v) = self.input_activate_stick_or_trackpad {
            my_size += ::protobuf::rt::value_size(12, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.activation_type {
            my_size += ::protobuf::rt::value_size(13, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.long_press_ms {
            my_size += ::protobuf::rt::value_size(14, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.double_press_ms {
            my_size += ::protobuf::rt::value_size(15, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.icon.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.input_source {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.input_mode {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.input_element {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.output_gamepad {
            os.write_int32(6, v)?;
        }
        if let Some(v) = self.output_keyboard {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.output_mouse {
            os.write_int32(8, v)?;
        }
        if let Some(ref v) = self.icon_foreground.as_ref() {
            os.write_string(9, &v)?;
        }
        if let Some(ref v) = self.icon_background.as_ref() {
            os.write_string(10, &v)?;
        }
        if let Some(v) = self.input_toggle {
            os.write_bool(11, v)?;
        }
        if let Some(v) = self.input_activate_stick_or_trackpad {
            os.write_int32(12, v)?;
        }
        if let Some(v) = self.activation_type {
            os.write_int32(13, v)?;
        }
        if let Some(v) = self.long_press_ms {
            os.write_int32(14, v)?;
        }
        if let Some(v) = self.double_press_ms {
            os.write_int32(15, 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() -> CVirtualControllerConfig_Control {
        CVirtualControllerConfig_Control::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CVirtualControllerConfig_Control| { &m.name },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "icon",
                |m: &CVirtualControllerConfig_Control| { &m.icon },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.icon },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "input_source",
                |m: &CVirtualControllerConfig_Control| { &m.input_source },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.input_source },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "input_mode",
                |m: &CVirtualControllerConfig_Control| { &m.input_mode },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.input_mode },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "input_element",
                |m: &CVirtualControllerConfig_Control| { &m.input_element },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.input_element },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "output_gamepad",
                |m: &CVirtualControllerConfig_Control| { &m.output_gamepad },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.output_gamepad },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "output_keyboard",
                |m: &CVirtualControllerConfig_Control| { &m.output_keyboard },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.output_keyboard },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "output_mouse",
                |m: &CVirtualControllerConfig_Control| { &m.output_mouse },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.output_mouse },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "icon_foreground",
                |m: &CVirtualControllerConfig_Control| { &m.icon_foreground },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.icon_foreground },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "icon_background",
                |m: &CVirtualControllerConfig_Control| { &m.icon_background },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.icon_background },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "input_toggle",
                |m: &CVirtualControllerConfig_Control| { &m.input_toggle },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.input_toggle },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "input_activate_stick_or_trackpad",
                |m: &CVirtualControllerConfig_Control| { &m.input_activate_stick_or_trackpad },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.input_activate_stick_or_trackpad },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "activation_type",
                |m: &CVirtualControllerConfig_Control| { &m.activation_type },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.activation_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "long_press_ms",
                |m: &CVirtualControllerConfig_Control| { &m.long_press_ms },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.long_press_ms },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "double_press_ms",
                |m: &CVirtualControllerConfig_Control| { &m.double_press_ms },
                |m: &mut CVirtualControllerConfig_Control| { &mut m.double_press_ms },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerConfig_Control>(
                "CVirtualControllerConfig.Control",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerConfig_Control {
    fn clear(&mut self) {
        self.name.clear();
        self.icon.clear();
        self.input_source = ::std::option::Option::None;
        self.input_mode = ::std::option::Option::None;
        self.input_element = ::std::option::Option::None;
        self.output_gamepad = ::std::option::Option::None;
        self.output_keyboard = ::std::option::Option::None;
        self.output_mouse = ::std::option::Option::None;
        self.icon_foreground.clear();
        self.icon_background.clear();
        self.input_toggle = ::std::option::Option::None;
        self.input_activate_stick_or_trackpad = ::std::option::Option::None;
        self.activation_type = ::std::option::Option::None;
        self.long_press_ms = ::std::option::Option::None;
        self.double_press_ms = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerConfig_ActionSet {
    // message fields
    id: ::std::option::Option<i32>,
    parent_id: ::std::option::Option<i32>,
    name: ::protobuf::SingularField<::std::string::String>,
    pub controls: ::protobuf::RepeatedField<CVirtualControllerConfig_Control>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 id = 1;


    pub fn get_id(&self) -> i32 {
        self.id.unwrap_or(0)
    }
    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

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

    // optional int32 parent_id = 2;


    pub fn get_parent_id(&self) -> i32 {
        self.parent_id.unwrap_or(0)
    }
    pub fn clear_parent_id(&mut self) {
        self.parent_id = ::std::option::Option::None;
    }

    pub fn has_parent_id(&self) -> bool {
        self.parent_id.is_some()
    }

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

    // optional string name = 3;


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

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

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

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

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

    // repeated .CVirtualControllerConfig.Control controls = 4;


    pub fn get_controls(&self) -> &[CVirtualControllerConfig_Control] {
        &self.controls
    }
    pub fn clear_controls(&mut self) {
        self.controls.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_controls(&mut self) -> &mut ::protobuf::RepeatedField<CVirtualControllerConfig_Control> {
        &mut self.controls
    }

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

impl ::protobuf::Message for CVirtualControllerConfig_ActionSet {
    fn is_initialized(&self) -> bool {
        for v in &self.controls {
            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_int32()?;
                    self.id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.parent_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.controls)?;
                },
                _ => {
                    ::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.id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.parent_id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        for value in &self.controls {
            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.id {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.parent_id {
            os.write_int32(2, v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(3, &v)?;
        }
        for v in &self.controls {
            os.write_tag(4, ::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() -> CVirtualControllerConfig_ActionSet {
        CVirtualControllerConfig_ActionSet::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>(
                "id",
                |m: &CVirtualControllerConfig_ActionSet| { &m.id },
                |m: &mut CVirtualControllerConfig_ActionSet| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "parent_id",
                |m: &CVirtualControllerConfig_ActionSet| { &m.parent_id },
                |m: &mut CVirtualControllerConfig_ActionSet| { &mut m.parent_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &CVirtualControllerConfig_ActionSet| { &m.name },
                |m: &mut CVirtualControllerConfig_ActionSet| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerConfig_Control>>(
                "controls",
                |m: &CVirtualControllerConfig_ActionSet| { &m.controls },
                |m: &mut CVirtualControllerConfig_ActionSet| { &mut m.controls },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerConfig_ActionSet>(
                "CVirtualControllerConfig.ActionSet",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerConfig_ActionSet {
    fn clear(&mut self) {
        self.id = ::std::option::Option::None;
        self.parent_id = ::std::option::Option::None;
        self.name.clear();
        self.controls.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerLayoutPackage {
    // message fields
    appid: ::std::option::Option<u32>,
    creator: ::std::option::Option<u64>,
    initial_revision: ::std::option::Option<u32>,
    saved_revision: ::std::option::Option<u32>,
    pub config: ::protobuf::SingularPtrField<CVirtualControllerConfig>,
    pub layouts: ::protobuf::SingularPtrField<CVirtualControllerLayouts>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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


    pub fn get_creator(&self) -> u64 {
        self.creator.unwrap_or(0)
    }
    pub fn clear_creator(&mut self) {
        self.creator = ::std::option::Option::None;
    }

    pub fn has_creator(&self) -> bool {
        self.creator.is_some()
    }

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

    // optional uint32 initial_revision = 3;


    pub fn get_initial_revision(&self) -> u32 {
        self.initial_revision.unwrap_or(0)
    }
    pub fn clear_initial_revision(&mut self) {
        self.initial_revision = ::std::option::Option::None;
    }

    pub fn has_initial_revision(&self) -> bool {
        self.initial_revision.is_some()
    }

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

    // optional uint32 saved_revision = 4;


    pub fn get_saved_revision(&self) -> u32 {
        self.saved_revision.unwrap_or(0)
    }
    pub fn clear_saved_revision(&mut self) {
        self.saved_revision = ::std::option::Option::None;
    }

    pub fn has_saved_revision(&self) -> bool {
        self.saved_revision.is_some()
    }

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

    // optional .CVirtualControllerConfig config = 5;


    pub fn get_config(&self) -> &CVirtualControllerConfig {
        self.config.as_ref().unwrap_or_else(|| <CVirtualControllerConfig as ::protobuf::Message>::default_instance())
    }
    pub fn clear_config(&mut self) {
        self.config.clear();
    }

    pub fn has_config(&self) -> bool {
        self.config.is_some()
    }

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

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

    // Take field
    pub fn take_config(&mut self) -> CVirtualControllerConfig {
        self.config.take().unwrap_or_else(|| CVirtualControllerConfig::new())
    }

    // optional .CVirtualControllerLayouts layouts = 6;


    pub fn get_layouts(&self) -> &CVirtualControllerLayouts {
        self.layouts.as_ref().unwrap_or_else(|| <CVirtualControllerLayouts as ::protobuf::Message>::default_instance())
    }
    pub fn clear_layouts(&mut self) {
        self.layouts.clear();
    }

    pub fn has_layouts(&self) -> bool {
        self.layouts.is_some()
    }

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

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

    // Take field
    pub fn take_layouts(&mut self) -> CVirtualControllerLayouts {
        self.layouts.take().unwrap_or_else(|| CVirtualControllerLayouts::new())
    }
}

impl ::protobuf::Message for CVirtualControllerLayoutPackage {
    fn is_initialized(&self) -> bool {
        for v in &self.config {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.layouts {
            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.creator = ::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.initial_revision = ::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.saved_revision = ::std::option::Option::Some(tmp);
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.config)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.layouts)?;
                },
                _ => {
                    ::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.creator {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.initial_revision {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.saved_revision {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.config.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.layouts.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(v) = self.creator {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.initial_revision {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.saved_revision {
            os.write_uint32(4, v)?;
        }
        if let Some(ref v) = self.config.as_ref() {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.layouts.as_ref() {
            os.write_tag(6, ::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() -> CVirtualControllerLayoutPackage {
        CVirtualControllerLayoutPackage::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: &CVirtualControllerLayoutPackage| { &m.appid },
                |m: &mut CVirtualControllerLayoutPackage| { &mut m.appid },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "creator",
                |m: &CVirtualControllerLayoutPackage| { &m.creator },
                |m: &mut CVirtualControllerLayoutPackage| { &mut m.creator },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "initial_revision",
                |m: &CVirtualControllerLayoutPackage| { &m.initial_revision },
                |m: &mut CVirtualControllerLayoutPackage| { &mut m.initial_revision },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "saved_revision",
                |m: &CVirtualControllerLayoutPackage| { &m.saved_revision },
                |m: &mut CVirtualControllerLayoutPackage| { &mut m.saved_revision },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerConfig>>(
                "config",
                |m: &CVirtualControllerLayoutPackage| { &m.config },
                |m: &mut CVirtualControllerLayoutPackage| { &mut m.config },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CVirtualControllerLayouts>>(
                "layouts",
                |m: &CVirtualControllerLayoutPackage| { &m.layouts },
                |m: &mut CVirtualControllerLayoutPackage| { &mut m.layouts },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CVirtualControllerLayoutPackage>(
                "CVirtualControllerLayoutPackage",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CVirtualControllerLayoutPackage {
    fn clear(&mut self) {
        self.appid = ::std::option::Option::None;
        self.creator = ::std::option::Option::None;
        self.initial_revision = ::std::option::Option::None;
        self.saved_revision = ::std::option::Option::None;
        self.config.clear();
        self.layouts.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CVirtualControllerGlobalConfig {
    // message fields
    feedback_enabled: ::std::option::Option<bool>,
    gyroscope_enabled: ::std::option::Option<bool>,
    auto_fade_enabled: ::std::option::Option<bool>,
    rumble_enabled: ::std::option::Option<bool>,
    shake_fade_enabled: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool feedback_enabled = 1;


    pub fn get_feedback_enabled(&self) -> bool {
        self.feedback_enabled.unwrap_or(false)
    }
    pub fn clear_feedback_enabled(&mut self) {
        self.feedback_enabled = ::std::option::Option::None;
    }

    pub fn has_feedback_enabled(&self) -> bool {
        self.feedback_enabled.is_some()
    }

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

    // optional bool gyroscope_enabled = 2;


    pub fn get_gyroscope_enabled(&self) -> bool {
        self.gyroscope_enabled.unwrap_or(true)
    }
    pub fn clear_gyroscope_enabled(&mut self) {
        self.gyroscope_enabled = ::std::option::Option::None;
    }

    pub fn has_gyroscope_enabled(&self) -> bool {
        self.gyroscope_enabled.is_some()
    }

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

    // optional bool auto_fade_enabled = 3;


    pub fn get_auto_fade_enabled(&self) -> bool {
        self.auto_fade_enabled.unwrap_or(true)
    }
    pub fn clear_auto_fade_enabled(&mut self) {
        self.auto_fade_enabled = ::std::option::Option::None;
    }

    pub fn has_auto_fade_enabled(&self) -> bool {
        self.auto_fade_enabled.is_some()
    }

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

    // optional bool rumble_enabled = 4;


    pub fn get_rumble_enabled(&self) -> bool {
        self.rumble_enabled.unwrap_or(true)
    }
    pub fn clear_rumble_enabled(&mut self) {
        self.rumble_enabled = ::std::option::Option::None;
    }

    pub fn has_rumble_enabled(&self) -> bool {
        self.rumble_enabled.is_some()
    }

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

    // optional bool shake_fade_enabled = 5;


    pub fn get_shake_fade_enabled(&self) -> bool {
        self.shake_fade_enabled.unwrap_or(false)
    }
    pub fn clear_shake_fade_enabled(&mut self) {
        self.shake_fade_enabled = ::std::option::Option::None;
    }

    pub fn has_shake_fade_enabled(&self) -> bool {
        self.shake_fade_enabled.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.feedback_enabled = ::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.gyroscope_enabled = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.auto_fade_enabled = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.rumble_enabled = ::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.shake_fade_enabled = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.feedback_enabled {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.gyroscope_enabled {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.auto_fade_enabled {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.rumble_enabled {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.shake_fade_enabled {
            os.write_bool(5, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for CVirtualControllerGlobalConfig {
    fn clear(&mut self) {
        self.feedback_enabled = ::std::option::Option::None;
        self.gyroscope_enabled = ::std::option::Option::None;
        self.auto_fade_enabled = ::std::option::Option::None;
        self.rumble_enabled = ::std::option::Option::None;
        self.shake_fade_enabled = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EInputMode {
    k_EInputModeUnknown = 0,
    k_EInputModeMouse = 1,
    k_EInputModeController = 2,
    k_EInputModeMouseAndController = 3,
}

impl ::protobuf::ProtobufEnum for EInputMode {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EInputMode> {
        match value {
            0 => ::std::option::Option::Some(EInputMode::k_EInputModeUnknown),
            1 => ::std::option::Option::Some(EInputMode::k_EInputModeMouse),
            2 => ::std::option::Option::Some(EInputMode::k_EInputModeController),
            3 => ::std::option::Option::Some(EInputMode::k_EInputModeMouseAndController),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EInputMode] = &[
            EInputMode::k_EInputModeUnknown,
            EInputMode::k_EInputModeMouse,
            EInputMode::k_EInputModeController,
            EInputMode::k_EInputModeMouseAndController,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EInputMode>("EInputMode", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EInputMode {
}

impl ::std::default::Default for EInputMode {
    fn default() -> Self {
        EInputMode::k_EInputModeUnknown
    }
}

impl ::protobuf::reflect::ProtobufValue for EInputMode {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EMouseMode {
    k_EMouseModeUnknown = 0,
    k_EMouseModeRelativeCursor = 1,
    k_EMouseModeAbsoluteCursor = 2,
    k_EMouseModeTouch = 3,
    k_EMouseModeRelative = 4,
}

impl ::protobuf::ProtobufEnum for EMouseMode {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EMouseMode> {
        match value {
            0 => ::std::option::Option::Some(EMouseMode::k_EMouseModeUnknown),
            1 => ::std::option::Option::Some(EMouseMode::k_EMouseModeRelativeCursor),
            2 => ::std::option::Option::Some(EMouseMode::k_EMouseModeAbsoluteCursor),
            3 => ::std::option::Option::Some(EMouseMode::k_EMouseModeTouch),
            4 => ::std::option::Option::Some(EMouseMode::k_EMouseModeRelative),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EMouseMode] = &[
            EMouseMode::k_EMouseModeUnknown,
            EMouseMode::k_EMouseModeRelativeCursor,
            EMouseMode::k_EMouseModeAbsoluteCursor,
            EMouseMode::k_EMouseModeTouch,
            EMouseMode::k_EMouseModeRelative,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EMouseMode>("EMouseMode", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EMouseMode {
}

impl ::std::default::Default for EMouseMode {
    fn default() -> Self {
        EMouseMode::k_EMouseModeUnknown
    }
}

impl ::protobuf::reflect::ProtobufValue for EMouseMode {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EControllerElementType {
    k_EControllerElementTypeNone = -1,
    k_EControllerElementTypeThumb = 0,
    k_EControllerElementTypeButtonSteam = 1,
    k_EControllerElementTypeJoystickLeft = 2,
    k_EControllerElementTypeButtonJoystickLeft = 3,
    k_EControllerElementTypeJoystickRight = 4,
    k_EControllerElementTypeButtonJoystickRight = 5,
    k_EControllerElementTypeDPad = 6,
    k_EControllerElementTypeButtonA = 7,
    k_EControllerElementTypeButtonB = 8,
    k_EControllerElementTypeButtonX = 9,
    k_EControllerElementTypeButtonY = 10,
    k_EControllerElementTypeButtonSelect = 11,
    k_EControllerElementTypeButtonStart = 12,
    k_EControllerElementTypeButtonTriggerLeft = 13,
    k_EControllerElementTypeButtonTriggerRight = 14,
    k_EControllerElementTypeButtonBumperLeft = 15,
    k_EControllerElementTypeButtonBumperRight = 16,
    k_EControllerElementTypeButtonMacro0 = 17,
    k_EControllerElementTypeButtonMacro1 = 18,
    k_EControllerElementTypeButtonMacro2 = 19,
    k_EControllerElementTypeButtonMacro3 = 20,
    k_EControllerElementTypeButtonMacro4 = 21,
    k_EControllerElementTypeButtonMacro5 = 22,
    k_EControllerElementTypeButtonMacro6 = 23,
    k_EControllerElementTypeButtonMacro7 = 24,
    k_EControllerElementTypeTrackpadCenter = 25,
    k_EControllerElementTypeTrackpadLeft = 26,
    k_EControllerElementTypeTrackpadRight = 27,
    k_EControllerElementTypeKeyboard = 28,
    k_EControllerElementTypeMagnifyingGlass = 29,
    k_EControllerElementTypeButtonMacro1Finger = 30,
    k_EControllerElementTypeButtonMacro2Finger = 31,
    k_EControllerElementTypeRecordInput = 32,
    k_EControllerElementTypePlaybackInput = 33,
    k_EControllerElementTypePaste = 34,
    k_EControllerElementTypeMax = 35,
}

impl ::protobuf::ProtobufEnum for EControllerElementType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EControllerElementType> {
        match value {
            -1 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeNone),
            0 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeThumb),
            1 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonSteam),
            2 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeJoystickLeft),
            3 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonJoystickLeft),
            4 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeJoystickRight),
            5 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonJoystickRight),
            6 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeDPad),
            7 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonA),
            8 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonB),
            9 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonX),
            10 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonY),
            11 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonSelect),
            12 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonStart),
            13 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonTriggerLeft),
            14 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonTriggerRight),
            15 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonBumperLeft),
            16 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonBumperRight),
            17 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro0),
            18 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro1),
            19 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro2),
            20 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro3),
            21 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro4),
            22 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro5),
            23 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro6),
            24 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro7),
            25 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadCenter),
            26 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadLeft),
            27 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeTrackpadRight),
            28 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeKeyboard),
            29 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeMagnifyingGlass),
            30 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro1Finger),
            31 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeButtonMacro2Finger),
            32 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeRecordInput),
            33 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypePlaybackInput),
            34 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypePaste),
            35 => ::std::option::Option::Some(EControllerElementType::k_EControllerElementTypeMax),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EControllerElementType] = &[
            EControllerElementType::k_EControllerElementTypeNone,
            EControllerElementType::k_EControllerElementTypeThumb,
            EControllerElementType::k_EControllerElementTypeButtonSteam,
            EControllerElementType::k_EControllerElementTypeJoystickLeft,
            EControllerElementType::k_EControllerElementTypeButtonJoystickLeft,
            EControllerElementType::k_EControllerElementTypeJoystickRight,
            EControllerElementType::k_EControllerElementTypeButtonJoystickRight,
            EControllerElementType::k_EControllerElementTypeDPad,
            EControllerElementType::k_EControllerElementTypeButtonA,
            EControllerElementType::k_EControllerElementTypeButtonB,
            EControllerElementType::k_EControllerElementTypeButtonX,
            EControllerElementType::k_EControllerElementTypeButtonY,
            EControllerElementType::k_EControllerElementTypeButtonSelect,
            EControllerElementType::k_EControllerElementTypeButtonStart,
            EControllerElementType::k_EControllerElementTypeButtonTriggerLeft,
            EControllerElementType::k_EControllerElementTypeButtonTriggerRight,
            EControllerElementType::k_EControllerElementTypeButtonBumperLeft,
            EControllerElementType::k_EControllerElementTypeButtonBumperRight,
            EControllerElementType::k_EControllerElementTypeButtonMacro0,
            EControllerElementType::k_EControllerElementTypeButtonMacro1,
            EControllerElementType::k_EControllerElementTypeButtonMacro2,
            EControllerElementType::k_EControllerElementTypeButtonMacro3,
            EControllerElementType::k_EControllerElementTypeButtonMacro4,
            EControllerElementType::k_EControllerElementTypeButtonMacro5,
            EControllerElementType::k_EControllerElementTypeButtonMacro6,
            EControllerElementType::k_EControllerElementTypeButtonMacro7,
            EControllerElementType::k_EControllerElementTypeTrackpadCenter,
            EControllerElementType::k_EControllerElementTypeTrackpadLeft,
            EControllerElementType::k_EControllerElementTypeTrackpadRight,
            EControllerElementType::k_EControllerElementTypeKeyboard,
            EControllerElementType::k_EControllerElementTypeMagnifyingGlass,
            EControllerElementType::k_EControllerElementTypeButtonMacro1Finger,
            EControllerElementType::k_EControllerElementTypeButtonMacro2Finger,
            EControllerElementType::k_EControllerElementTypeRecordInput,
            EControllerElementType::k_EControllerElementTypePlaybackInput,
            EControllerElementType::k_EControllerElementTypePaste,
            EControllerElementType::k_EControllerElementTypeMax,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EControllerElementType>("EControllerElementType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EControllerElementType {
}

// Note, `Default` is implemented although default value is not 0
impl ::std::default::Default for EControllerElementType {
    fn default() -> Self {
        EControllerElementType::k_EControllerElementTypeNone
    }
}

impl ::protobuf::reflect::ProtobufValue for EControllerElementType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n%steammessages_virtualcontroller.proto\"\xf6\x01\n\x19CVirtualControll\
    erElement\x12I\n\x04type\x18\x01\x20\x01(\x0e2\x17.EControllerElementTyp\
    e:\x1ck_EControllerElementTypeNoneR\x04type\x12\x18\n\x07visible\x18\x02\
    \x20\x01(\x08R\x07visible\x12\x1d\n\nx_position\x18\x03\x20\x01(\x02R\tx\
    Position\x12\x1d\n\ny_position\x18\x04\x20\x01(\x02R\tyPosition\x12\x1a\
    \n\x07x_scale\x18\x05\x20\x01(\x02:\x011R\x06xScale\x12\x1a\n\x07y_scale\
    \x18\x06\x20\x01(\x02:\x011R\x06yScale\"]\n\x17CVirtualControllerColor\
    \x12\x0f\n\x01r\x18\x01\x20\x01(\x02:\x011R\x01r\x12\x0f\n\x01g\x18\x02\
    \x20\x01(\x02:\x011R\x01g\x12\x0f\n\x01b\x18\x03\x20\x01(\x02:\x011R\x01\
    b\x12\x0f\n\x01a\x18\x04\x20\x01(\x02:\x011R\x01a\"\xcc\x01\n\x18CVirtua\
    lControllerLayout\x12%\n\x0elayout_version\x18\x01\x20\x01(\x05R\rlayout\
    Version\x12!\n\x0cactionset_id\x18\x02\x20\x01(\x05R\x0bactionsetId\x126\
    \n\x08elements\x18\x04\x20\x03(\x0b2\x1a.CVirtualControllerElementR\x08e\
    lements\x12.\n\x05color\x18\x05\x20\x01(\x0b2\x18.CVirtualControllerColo\
    rR\x05color\"\xf8\x03\n\x19CVirtualControllerLayouts\x123\n\x07layouts\
    \x18\x01\x20\x03(\x0b2\x19.CVirtualControllerLayoutR\x07layouts\x12B\n\n\
    input_mode\x18\x02\x20\x01(\x0e2\x0b.EInputMode:\x16k_EInputModeControll\
    erR\tinputMode\x12?\n\nmouse_mode\x18\x03\x20\x01(\x0e2\x0b.EMouseMode:\
    \x13k_EMouseModeUnknownR\tmouseMode\x124\n\x14trackpad_sensitivity\x18\
    \x04\x20\x01(\x02:\x011R\x13trackpadSensitivity\x123\n\x12pinch_zoom_ena\
    bled\x18\x05\x20\x01(\x08:\x05falseR\x10pinchZoomEnabled\x12#\n\x0cpinch\
    _zoom_x\x18\x06\x20\x01(\x02:\x010R\npinchZoomX\x12#\n\x0cpinch_zoom_y\
    \x18\x07\x20\x01(\x02:\x010R\npinchZoomY\x12+\n\x10pinch_zoom_scale\x18\
    \x08\x20\x01(\x02:\x011R\x0epinchZoomScale\x12\x16\n\x06shaken\x18\t\x20\
    \x01(\x08R\x06shaken\x12'\n\x0fmouse_offscreen\x18\n\x20\x01(\x08R\x0emo\
    useOffscreen\"\x92\x07\n\x18CVirtualControllerConfig\x12\x12\n\x04name\
    \x18\x01\x20\x01(\tR\x04name\x12C\n\nactionsets\x18\x02\x20\x03(\x0b2#.C\
    VirtualControllerConfig.ActionSetR\nactionsets\x12O\n\x12default_mouse_m\
    ode\x18\x03\x20\x01(\x0e2\x0b.EMouseMode:\x14k_EMouseModeRelativeR\x10de\
    faultMouseMode\x1a\xbd\x04\n\x07Control\x12\x12\n\x04name\x18\x01\x20\
    \x01(\tR\x04name\x12\x12\n\x04icon\x18\x02\x20\x01(\tR\x04icon\x12!\n\
    \x0cinput_source\x18\x03\x20\x01(\x05R\x0binputSource\x12\x1d\n\ninput_m\
    ode\x18\x04\x20\x01(\x05R\tinputMode\x12#\n\rinput_element\x18\x05\x20\
    \x01(\x05R\x0cinputElement\x12%\n\x0eoutput_gamepad\x18\x06\x20\x01(\x05\
    R\routputGamepad\x12'\n\x0foutput_keyboard\x18\x07\x20\x01(\x05R\x0eoutp\
    utKeyboard\x12!\n\x0coutput_mouse\x18\x08\x20\x01(\x05R\x0boutputMouse\
    \x12'\n\x0ficon_foreground\x18\t\x20\x01(\tR\x0eiconForeground\x12'\n\
    \x0ficon_background\x18\n\x20\x01(\tR\x0eiconBackground\x12!\n\x0cinput_\
    toggle\x18\x0b\x20\x01(\x08R\x0binputToggle\x12F\n\x20input_activate_sti\
    ck_or_trackpad\x18\x0c\x20\x01(\x05R\x1cinputActivateStickOrTrackpad\x12\
    '\n\x0factivation_type\x18\r\x20\x01(\x05R\x0eactivationType\x12\"\n\rlo\
    ng_press_ms\x18\x0e\x20\x01(\x05R\x0blongPressMs\x12&\n\x0fdouble_press_\
    ms\x18\x0f\x20\x01(\x05R\rdoublePressMs\x1a\x8b\x01\n\tActionSet\x12\x0e\
    \n\x02id\x18\x01\x20\x01(\x05R\x02id\x12\x1b\n\tparent_id\x18\x02\x20\
    \x01(\x05R\x08parentId\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\
    =\n\x08controls\x18\x04\x20\x03(\x0b2!.CVirtualControllerConfig.ControlR\
    \x08controls\"\x8c\x02\n\x1fCVirtualControllerLayoutPackage\x12\x14\n\
    \x05appid\x18\x01\x20\x01(\rR\x05appid\x12\x18\n\x07creator\x18\x02\x20\
    \x01(\x04R\x07creator\x12)\n\x10initial_revision\x18\x03\x20\x01(\rR\x0f\
    initialRevision\x12%\n\x0esaved_revision\x18\x04\x20\x01(\rR\rsavedRevis\
    ion\x121\n\x06config\x18\x05\x20\x01(\x0b2\x19.CVirtualControllerConfigR\
    \x06config\x124\n\x07layouts\x18\x06\x20\x01(\x0b2\x1a.CVirtualControlle\
    rLayoutsR\x07layouts\"\x8b\x02\n\x1eCVirtualControllerGlobalConfig\x12)\
    \n\x10feedback_enabled\x18\x01\x20\x01(\x08R\x0ffeedbackEnabled\x121\n\
    \x11gyroscope_enabled\x18\x02\x20\x01(\x08:\x04trueR\x10gyroscopeEnabled\
    \x120\n\x11auto_fade_enabled\x18\x03\x20\x01(\x08:\x04trueR\x0fautoFadeE\
    nabled\x12+\n\x0erumble_enabled\x18\x04\x20\x01(\x08:\x04trueR\rrumbleEn\
    abled\x12,\n\x12shake_fade_enabled\x18\x05\x20\x01(\x08R\x10shakeFadeEna\
    bled*|\n\nEInputMode\x12\x17\n\x13k_EInputModeUnknown\x10\0\x12\x15\n\
    \x11k_EInputModeMouse\x10\x01\x12\x1a\n\x16k_EInputModeController\x10\
    \x02\x12\"\n\x1ek_EInputModeMouseAndController\x10\x03*\x96\x01\n\nEMous\
    eMode\x12\x17\n\x13k_EMouseModeUnknown\x10\0\x12\x1e\n\x1ak_EMouseModeRe\
    lativeCursor\x10\x01\x12\x1e\n\x1ak_EMouseModeAbsoluteCursor\x10\x02\x12\
    \x15\n\x11k_EMouseModeTouch\x10\x03\x12\x18\n\x14k_EMouseModeRelative\
    \x10\x04*\xa6\x0c\n\x16EControllerElementType\x12)\n\x1ck_EControllerEle\
    mentTypeNone\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x12!\n\x1dk_ECo\
    ntrollerElementTypeThumb\x10\0\x12'\n#k_EControllerElementTypeButtonStea\
    m\x10\x01\x12(\n$k_EControllerElementTypeJoystickLeft\x10\x02\x12.\n*k_E\
    ControllerElementTypeButtonJoystickLeft\x10\x03\x12)\n%k_EControllerElem\
    entTypeJoystickRight\x10\x04\x12/\n+k_EControllerElementTypeButtonJoysti\
    ckRight\x10\x05\x12\x20\n\x1ck_EControllerElementTypeDPad\x10\x06\x12#\n\
    \x1fk_EControllerElementTypeButtonA\x10\x07\x12#\n\x1fk_EControllerEleme\
    ntTypeButtonB\x10\x08\x12#\n\x1fk_EControllerElementTypeButtonX\x10\t\
    \x12#\n\x1fk_EControllerElementTypeButtonY\x10\n\x12(\n$k_EControllerEle\
    mentTypeButtonSelect\x10\x0b\x12'\n#k_EControllerElementTypeButtonStart\
    \x10\x0c\x12-\n)k_EControllerElementTypeButtonTriggerLeft\x10\r\x12.\n*k\
    _EControllerElementTypeButtonTriggerRight\x10\x0e\x12,\n(k_EControllerEl\
    ementTypeButtonBumperLeft\x10\x0f\x12-\n)k_EControllerElementTypeButtonB\
    umperRight\x10\x10\x12(\n$k_EControllerElementTypeButtonMacro0\x10\x11\
    \x12(\n$k_EControllerElementTypeButtonMacro1\x10\x12\x12(\n$k_EControlle\
    rElementTypeButtonMacro2\x10\x13\x12(\n$k_EControllerElementTypeButtonMa\
    cro3\x10\x14\x12(\n$k_EControllerElementTypeButtonMacro4\x10\x15\x12(\n$\
    k_EControllerElementTypeButtonMacro5\x10\x16\x12(\n$k_EControllerElement\
    TypeButtonMacro6\x10\x17\x12(\n$k_EControllerElementTypeButtonMacro7\x10\
    \x18\x12*\n&k_EControllerElementTypeTrackpadCenter\x10\x19\x12(\n$k_ECon\
    trollerElementTypeTrackpadLeft\x10\x1a\x12)\n%k_EControllerElementTypeTr\
    ackpadRight\x10\x1b\x12$\n\x20k_EControllerElementTypeKeyboard\x10\x1c\
    \x12+\n'k_EControllerElementTypeMagnifyingGlass\x10\x1d\x12.\n*k_EContro\
    llerElementTypeButtonMacro1Finger\x10\x1e\x12.\n*k_EControllerElementTyp\
    eButtonMacro2Finger\x10\x1f\x12'\n#k_EControllerElementTypeRecordInput\
    \x10\x20\x12)\n%k_EControllerElementTypePlaybackInput\x10!\x12!\n\x1dk_E\
    ControllerElementTypePaste\x10\"\x12\x1f\n\x1bk_EControllerElementTypeMa\
    x\x10#J\xca5\n\x07\x12\x05\0\0\x89\x01\x01\n\n\n\x02\x05\0\x12\x04\0\0\
    \x05\x01\n\n\n\x03\x05\0\x01\x12\x03\0\x05\x0f\n\x0b\n\x04\x05\0\x02\0\
    \x12\x03\x01\x08\x20\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x01\x08\x1b\n\
    \x0c\n\x05\x05\0\x02\0\x02\x12\x03\x01\x1e\x1f\n\x0b\n\x04\x05\0\x02\x01\
    \x12\x03\x02\x08\x1e\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x02\x08\x19\n\
    \x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x02\x1c\x1d\n\x0b\n\x04\x05\0\x02\
    \x02\x12\x03\x03\x08#\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03\x03\x08\x1e\
    \n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\x03!\"\n\x0b\n\x04\x05\0\x02\x03\
    \x12\x03\x04\x08+\n\x0c\n\x05\x05\0\x02\x03\x01\x12\x03\x04\x08&\n\x0c\n\
    \x05\x05\0\x02\x03\x02\x12\x03\x04)*\n\n\n\x02\x05\x01\x12\x04\x07\0\r\
    \x01\n\n\n\x03\x05\x01\x01\x12\x03\x07\x05\x0f\n\x0b\n\x04\x05\x01\x02\0\
    \x12\x03\x08\x08\x20\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03\x08\x08\x1b\n\
    \x0c\n\x05\x05\x01\x02\0\x02\x12\x03\x08\x1e\x1f\n\x0b\n\x04\x05\x01\x02\
    \x01\x12\x03\t\x08'\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03\t\x08\"\n\
    \x0c\n\x05\x05\x01\x02\x01\x02\x12\x03\t%&\n\x0b\n\x04\x05\x01\x02\x02\
    \x12\x03\n\x08'\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x03\n\x08\"\n\x0c\n\
    \x05\x05\x01\x02\x02\x02\x12\x03\n%&\n\x0b\n\x04\x05\x01\x02\x03\x12\x03\
    \x0b\x08\x1e\n\x0c\n\x05\x05\x01\x02\x03\x01\x12\x03\x0b\x08\x19\n\x0c\n\
    \x05\x05\x01\x02\x03\x02\x12\x03\x0b\x1c\x1d\n\x0b\n\x04\x05\x01\x02\x04\
    \x12\x03\x0c\x08!\n\x0c\n\x05\x05\x01\x02\x04\x01\x12\x03\x0c\x08\x1c\n\
    \x0c\n\x05\x05\x01\x02\x04\x02\x12\x03\x0c\x1f\x20\n\n\n\x02\x05\x02\x12\
    \x04\x0f\05\x01\n\n\n\x03\x05\x02\x01\x12\x03\x0f\x05\x1b\n\x0b\n\x04\
    \x05\x02\x02\0\x12\x03\x10\x08*\n\x0c\n\x05\x05\x02\x02\0\x01\x12\x03\
    \x10\x08$\n\x0c\n\x05\x05\x02\x02\0\x02\x12\x03\x10')\n\x0b\n\x04\x05\
    \x02\x02\x01\x12\x03\x11\x08*\n\x0c\n\x05\x05\x02\x02\x01\x01\x12\x03\
    \x11\x08%\n\x0c\n\x05\x05\x02\x02\x01\x02\x12\x03\x11()\n\x0b\n\x04\x05\
    \x02\x02\x02\x12\x03\x12\x080\n\x0c\n\x05\x05\x02\x02\x02\x01\x12\x03\
    \x12\x08+\n\x0c\n\x05\x05\x02\x02\x02\x02\x12\x03\x12./\n\x0b\n\x04\x05\
    \x02\x02\x03\x12\x03\x13\x081\n\x0c\n\x05\x05\x02\x02\x03\x01\x12\x03\
    \x13\x08,\n\x0c\n\x05\x05\x02\x02\x03\x02\x12\x03\x13/0\n\x0b\n\x04\x05\
    \x02\x02\x04\x12\x03\x14\x087\n\x0c\n\x05\x05\x02\x02\x04\x01\x12\x03\
    \x14\x082\n\x0c\n\x05\x05\x02\x02\x04\x02\x12\x03\x1456\n\x0b\n\x04\x05\
    \x02\x02\x05\x12\x03\x15\x082\n\x0c\n\x05\x05\x02\x02\x05\x01\x12\x03\
    \x15\x08-\n\x0c\n\x05\x05\x02\x02\x05\x02\x12\x03\x1501\n\x0b\n\x04\x05\
    \x02\x02\x06\x12\x03\x16\x088\n\x0c\n\x05\x05\x02\x02\x06\x01\x12\x03\
    \x16\x083\n\x0c\n\x05\x05\x02\x02\x06\x02\x12\x03\x1667\n\x0b\n\x04\x05\
    \x02\x02\x07\x12\x03\x17\x08)\n\x0c\n\x05\x05\x02\x02\x07\x01\x12\x03\
    \x17\x08$\n\x0c\n\x05\x05\x02\x02\x07\x02\x12\x03\x17'(\n\x0b\n\x04\x05\
    \x02\x02\x08\x12\x03\x18\x08,\n\x0c\n\x05\x05\x02\x02\x08\x01\x12\x03\
    \x18\x08'\n\x0c\n\x05\x05\x02\x02\x08\x02\x12\x03\x18*+\n\x0b\n\x04\x05\
    \x02\x02\t\x12\x03\x19\x08,\n\x0c\n\x05\x05\x02\x02\t\x01\x12\x03\x19\
    \x08'\n\x0c\n\x05\x05\x02\x02\t\x02\x12\x03\x19*+\n\x0b\n\x04\x05\x02\
    \x02\n\x12\x03\x1a\x08,\n\x0c\n\x05\x05\x02\x02\n\x01\x12\x03\x1a\x08'\n\
    \x0c\n\x05\x05\x02\x02\n\x02\x12\x03\x1a*+\n\x0b\n\x04\x05\x02\x02\x0b\
    \x12\x03\x1b\x08-\n\x0c\n\x05\x05\x02\x02\x0b\x01\x12\x03\x1b\x08'\n\x0c\
    \n\x05\x05\x02\x02\x0b\x02\x12\x03\x1b*,\n\x0b\n\x04\x05\x02\x02\x0c\x12\
    \x03\x1c\x082\n\x0c\n\x05\x05\x02\x02\x0c\x01\x12\x03\x1c\x08,\n\x0c\n\
    \x05\x05\x02\x02\x0c\x02\x12\x03\x1c/1\n\x0b\n\x04\x05\x02\x02\r\x12\x03\
    \x1d\x081\n\x0c\n\x05\x05\x02\x02\r\x01\x12\x03\x1d\x08+\n\x0c\n\x05\x05\
    \x02\x02\r\x02\x12\x03\x1d.0\n\x0b\n\x04\x05\x02\x02\x0e\x12\x03\x1e\x08\
    7\n\x0c\n\x05\x05\x02\x02\x0e\x01\x12\x03\x1e\x081\n\x0c\n\x05\x05\x02\
    \x02\x0e\x02\x12\x03\x1e46\n\x0b\n\x04\x05\x02\x02\x0f\x12\x03\x1f\x088\
    \n\x0c\n\x05\x05\x02\x02\x0f\x01\x12\x03\x1f\x082\n\x0c\n\x05\x05\x02\
    \x02\x0f\x02\x12\x03\x1f57\n\x0b\n\x04\x05\x02\x02\x10\x12\x03\x20\x086\
    \n\x0c\n\x05\x05\x02\x02\x10\x01\x12\x03\x20\x080\n\x0c\n\x05\x05\x02\
    \x02\x10\x02\x12\x03\x2035\n\x0b\n\x04\x05\x02\x02\x11\x12\x03!\x087\n\
    \x0c\n\x05\x05\x02\x02\x11\x01\x12\x03!\x081\n\x0c\n\x05\x05\x02\x02\x11\
    \x02\x12\x03!46\n\x0b\n\x04\x05\x02\x02\x12\x12\x03\"\x082\n\x0c\n\x05\
    \x05\x02\x02\x12\x01\x12\x03\"\x08,\n\x0c\n\x05\x05\x02\x02\x12\x02\x12\
    \x03\"/1\n\x0b\n\x04\x05\x02\x02\x13\x12\x03#\x082\n\x0c\n\x05\x05\x02\
    \x02\x13\x01\x12\x03#\x08,\n\x0c\n\x05\x05\x02\x02\x13\x02\x12\x03#/1\n\
    \x0b\n\x04\x05\x02\x02\x14\x12\x03$\x082\n\x0c\n\x05\x05\x02\x02\x14\x01\
    \x12\x03$\x08,\n\x0c\n\x05\x05\x02\x02\x14\x02\x12\x03$/1\n\x0b\n\x04\
    \x05\x02\x02\x15\x12\x03%\x082\n\x0c\n\x05\x05\x02\x02\x15\x01\x12\x03%\
    \x08,\n\x0c\n\x05\x05\x02\x02\x15\x02\x12\x03%/1\n\x0b\n\x04\x05\x02\x02\
    \x16\x12\x03&\x082\n\x0c\n\x05\x05\x02\x02\x16\x01\x12\x03&\x08,\n\x0c\n\
    \x05\x05\x02\x02\x16\x02\x12\x03&/1\n\x0b\n\x04\x05\x02\x02\x17\x12\x03'\
    \x082\n\x0c\n\x05\x05\x02\x02\x17\x01\x12\x03'\x08,\n\x0c\n\x05\x05\x02\
    \x02\x17\x02\x12\x03'/1\n\x0b\n\x04\x05\x02\x02\x18\x12\x03(\x082\n\x0c\
    \n\x05\x05\x02\x02\x18\x01\x12\x03(\x08,\n\x0c\n\x05\x05\x02\x02\x18\x02\
    \x12\x03(/1\n\x0b\n\x04\x05\x02\x02\x19\x12\x03)\x082\n\x0c\n\x05\x05\
    \x02\x02\x19\x01\x12\x03)\x08,\n\x0c\n\x05\x05\x02\x02\x19\x02\x12\x03)/\
    1\n\x0b\n\x04\x05\x02\x02\x1a\x12\x03*\x084\n\x0c\n\x05\x05\x02\x02\x1a\
    \x01\x12\x03*\x08.\n\x0c\n\x05\x05\x02\x02\x1a\x02\x12\x03*13\n\x0b\n\
    \x04\x05\x02\x02\x1b\x12\x03+\x082\n\x0c\n\x05\x05\x02\x02\x1b\x01\x12\
    \x03+\x08,\n\x0c\n\x05\x05\x02\x02\x1b\x02\x12\x03+/1\n\x0b\n\x04\x05\
    \x02\x02\x1c\x12\x03,\x083\n\x0c\n\x05\x05\x02\x02\x1c\x01\x12\x03,\x08-\
    \n\x0c\n\x05\x05\x02\x02\x1c\x02\x12\x03,02\n\x0b\n\x04\x05\x02\x02\x1d\
    \x12\x03-\x08.\n\x0c\n\x05\x05\x02\x02\x1d\x01\x12\x03-\x08(\n\x0c\n\x05\
    \x05\x02\x02\x1d\x02\x12\x03-+-\n\x0b\n\x04\x05\x02\x02\x1e\x12\x03.\x08\
    5\n\x0c\n\x05\x05\x02\x02\x1e\x01\x12\x03.\x08/\n\x0c\n\x05\x05\x02\x02\
    \x1e\x02\x12\x03.24\n\x0b\n\x04\x05\x02\x02\x1f\x12\x03/\x088\n\x0c\n\
    \x05\x05\x02\x02\x1f\x01\x12\x03/\x082\n\x0c\n\x05\x05\x02\x02\x1f\x02\
    \x12\x03/57\n\x0b\n\x04\x05\x02\x02\x20\x12\x030\x088\n\x0c\n\x05\x05\
    \x02\x02\x20\x01\x12\x030\x082\n\x0c\n\x05\x05\x02\x02\x20\x02\x12\x0305\
    7\n\x0b\n\x04\x05\x02\x02!\x12\x031\x081\n\x0c\n\x05\x05\x02\x02!\x01\
    \x12\x031\x08+\n\x0c\n\x05\x05\x02\x02!\x02\x12\x031.0\n\x0b\n\x04\x05\
    \x02\x02\"\x12\x032\x083\n\x0c\n\x05\x05\x02\x02\"\x01\x12\x032\x08-\n\
    \x0c\n\x05\x05\x02\x02\"\x02\x12\x03202\n\x0b\n\x04\x05\x02\x02#\x12\x03\
    3\x08+\n\x0c\n\x05\x05\x02\x02#\x01\x12\x033\x08%\n\x0c\n\x05\x05\x02\
    \x02#\x02\x12\x033(*\n\x0b\n\x04\x05\x02\x02$\x12\x034\x08)\n\x0c\n\x05\
    \x05\x02\x02$\x01\x12\x034\x08#\n\x0c\n\x05\x05\x02\x02$\x02\x12\x034&(\
    \n\n\n\x02\x04\0\x12\x047\0>\x01\n\n\n\x03\x04\0\x01\x12\x037\x08!\n\x0b\
    \n\x04\x04\0\x02\0\x12\x038\x08[\n\x0c\n\x05\x04\0\x02\0\x04\x12\x038\
    \x08\x10\n\x0c\n\x05\x04\0\x02\0\x06\x12\x038\x11(\n\x0c\n\x05\x04\0\x02\
    \0\x01\x12\x038)-\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03801\n\x0c\n\x05\x04\
    \0\x02\0\x08\x12\x0382Z\n\x0c\n\x05\x04\0\x02\0\x07\x12\x038=Y\n\x0b\n\
    \x04\x04\0\x02\x01\x12\x039\x08\"\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x039\
    \x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x039\x11\x15\n\x0c\n\x05\x04\
    \0\x02\x01\x01\x12\x039\x16\x1d\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x039\
    \x20!\n\x0b\n\x04\x04\0\x02\x02\x12\x03:\x08&\n\x0c\n\x05\x04\0\x02\x02\
    \x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03:\x11\x16\n\
    \x0c\n\x05\x04\0\x02\x02\x01\x12\x03:\x17!\n\x0c\n\x05\x04\0\x02\x02\x03\
    \x12\x03:$%\n\x0b\n\x04\x04\0\x02\x03\x12\x03;\x08&\n\x0c\n\x05\x04\0\
    \x02\x03\x04\x12\x03;\x08\x10\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03;\x11\
    \x16\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03;\x17!\n\x0c\n\x05\x04\0\x02\
    \x03\x03\x12\x03;$%\n\x0b\n\x04\x04\0\x02\x04\x12\x03<\x081\n\x0c\n\x05\
    \x04\0\x02\x04\x04\x12\x03<\x08\x10\n\x0c\n\x05\x04\0\x02\x04\x05\x12\
    \x03<\x11\x16\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03<\x17\x1e\n\x0c\n\x05\
    \x04\0\x02\x04\x03\x12\x03<!\"\n\x0c\n\x05\x04\0\x02\x04\x08\x12\x03<#0\
    \n\x0c\n\x05\x04\0\x02\x04\x07\x12\x03<./\n\x0b\n\x04\x04\0\x02\x05\x12\
    \x03=\x081\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x03=\x08\x10\n\x0c\n\x05\
    \x04\0\x02\x05\x05\x12\x03=\x11\x16\n\x0c\n\x05\x04\0\x02\x05\x01\x12\
    \x03=\x17\x1e\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03=!\"\n\x0c\n\x05\x04\
    \0\x02\x05\x08\x12\x03=#0\n\x0c\n\x05\x04\0\x02\x05\x07\x12\x03=./\n\n\n\
    \x02\x04\x01\x12\x04@\0E\x01\n\n\n\x03\x04\x01\x01\x12\x03@\x08\x1f\n\
    \x0b\n\x04\x04\x01\x02\0\x12\x03A\x08+\n\x0c\n\x05\x04\x01\x02\0\x04\x12\
    \x03A\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03A\x11\x16\n\x0c\n\x05\
    \x04\x01\x02\0\x01\x12\x03A\x17\x18\n\x0c\n\x05\x04\x01\x02\0\x03\x12\
    \x03A\x1b\x1c\n\x0c\n\x05\x04\x01\x02\0\x08\x12\x03A\x1d*\n\x0c\n\x05\
    \x04\x01\x02\0\x07\x12\x03A()\n\x0b\n\x04\x04\x01\x02\x01\x12\x03B\x08+\
    \n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03B\x08\x10\n\x0c\n\x05\x04\x01\
    \x02\x01\x05\x12\x03B\x11\x16\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03B\
    \x17\x18\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03B\x1b\x1c\n\x0c\n\x05\
    \x04\x01\x02\x01\x08\x12\x03B\x1d*\n\x0c\n\x05\x04\x01\x02\x01\x07\x12\
    \x03B()\n\x0b\n\x04\x04\x01\x02\x02\x12\x03C\x08+\n\x0c\n\x05\x04\x01\
    \x02\x02\x04\x12\x03C\x08\x10\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03C\
    \x11\x16\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03C\x17\x18\n\x0c\n\x05\
    \x04\x01\x02\x02\x03\x12\x03C\x1b\x1c\n\x0c\n\x05\x04\x01\x02\x02\x08\
    \x12\x03C\x1d*\n\x0c\n\x05\x04\x01\x02\x02\x07\x12\x03C()\n\x0b\n\x04\
    \x04\x01\x02\x03\x12\x03D\x08+\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03D\
    \x08\x10\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03D\x11\x16\n\x0c\n\x05\
    \x04\x01\x02\x03\x01\x12\x03D\x17\x18\n\x0c\n\x05\x04\x01\x02\x03\x03\
    \x12\x03D\x1b\x1c\n\x0c\n\x05\x04\x01\x02\x03\x08\x12\x03D\x1d*\n\x0c\n\
    \x05\x04\x01\x02\x03\x07\x12\x03D()\n\n\n\x02\x04\x02\x12\x04G\0L\x01\n\
    \n\n\x03\x04\x02\x01\x12\x03G\x08\x20\n\x0b\n\x04\x04\x02\x02\0\x12\x03H\
    \x08*\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03H\x08\x10\n\x0c\n\x05\x04\x02\
    \x02\0\x05\x12\x03H\x11\x16\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03H\x17%\
    \n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03H()\n\x0b\n\x04\x04\x02\x02\x01\
    \x12\x03I\x08(\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03I\x08\x10\n\x0c\n\
    \x05\x04\x02\x02\x01\x05\x12\x03I\x11\x16\n\x0c\n\x05\x04\x02\x02\x01\
    \x01\x12\x03I\x17#\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03I&'\n\x0b\n\
    \x04\x04\x02\x02\x02\x12\x03J\x089\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\
    \x03J\x08\x10\n\x0c\n\x05\x04\x02\x02\x02\x06\x12\x03J\x11+\n\x0c\n\x05\
    \x04\x02\x02\x02\x01\x12\x03J,4\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03J\
    78\n\x0b\n\x04\x04\x02\x02\x03\x12\x03K\x084\n\x0c\n\x05\x04\x02\x02\x03\
    \x04\x12\x03K\x08\x10\n\x0c\n\x05\x04\x02\x02\x03\x06\x12\x03K\x11)\n\
    \x0c\n\x05\x04\x02\x02\x03\x01\x12\x03K*/\n\x0c\n\x05\x04\x02\x02\x03\
    \x03\x12\x03K23\n\n\n\x02\x04\x03\x12\x04N\0Y\x01\n\n\n\x03\x04\x03\x01\
    \x12\x03N\x08!\n\x0b\n\x04\x04\x03\x02\0\x12\x03O\x087\n\x0c\n\x05\x04\
    \x03\x02\0\x04\x12\x03O\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03O\
    \x11*\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03O+2\n\x0c\n\x05\x04\x03\x02\0\
    \x03\x12\x03O56\n\x0b\n\x04\x04\x03\x02\x01\x12\x03P\x08O\n\x0c\n\x05\
    \x04\x03\x02\x01\x04\x12\x03P\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\x06\
    \x12\x03P\x11\x1c\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03P\x1d'\n\x0c\n\
    \x05\x04\x03\x02\x01\x03\x12\x03P*+\n\x0c\n\x05\x04\x03\x02\x01\x08\x12\
    \x03P,N\n\x0c\n\x05\x04\x03\x02\x01\x07\x12\x03P7M\n\x0b\n\x04\x04\x03\
    \x02\x02\x12\x03Q\x08L\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03Q\x08\x10\
    \n\x0c\n\x05\x04\x03\x02\x02\x06\x12\x03Q\x11\x1c\n\x0c\n\x05\x04\x03\
    \x02\x02\x01\x12\x03Q\x1d'\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03Q*+\n\
    \x0c\n\x05\x04\x03\x02\x02\x08\x12\x03Q,K\n\x0c\n\x05\x04\x03\x02\x02\
    \x07\x12\x03Q7J\n\x0b\n\x04\x04\x03\x02\x03\x12\x03R\x08>\n\x0c\n\x05\
    \x04\x03\x02\x03\x04\x12\x03R\x08\x10\n\x0c\n\x05\x04\x03\x02\x03\x05\
    \x12\x03R\x11\x16\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03R\x17+\n\x0c\n\
    \x05\x04\x03\x02\x03\x03\x12\x03R./\n\x0c\n\x05\x04\x03\x02\x03\x08\x12\
    \x03R0=\n\x0c\n\x05\x04\x03\x02\x03\x07\x12\x03R;<\n\x0b\n\x04\x04\x03\
    \x02\x04\x12\x03S\x08?\n\x0c\n\x05\x04\x03\x02\x04\x04\x12\x03S\x08\x10\
    \n\x0c\n\x05\x04\x03\x02\x04\x05\x12\x03S\x11\x15\n\x0c\n\x05\x04\x03\
    \x02\x04\x01\x12\x03S\x16(\n\x0c\n\x05\x04\x03\x02\x04\x03\x12\x03S+,\n\
    \x0c\n\x05\x04\x03\x02\x04\x08\x12\x03S->\n\x0c\n\x05\x04\x03\x02\x04\
    \x07\x12\x03S8=\n\x0b\n\x04\x04\x03\x02\x05\x12\x03T\x086\n\x0c\n\x05\
    \x04\x03\x02\x05\x04\x12\x03T\x08\x10\n\x0c\n\x05\x04\x03\x02\x05\x05\
    \x12\x03T\x11\x16\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x03T\x17#\n\x0c\n\
    \x05\x04\x03\x02\x05\x03\x12\x03T&'\n\x0c\n\x05\x04\x03\x02\x05\x08\x12\
    \x03T(5\n\x0c\n\x05\x04\x03\x02\x05\x07\x12\x03T34\n\x0b\n\x04\x04\x03\
    \x02\x06\x12\x03U\x086\n\x0c\n\x05\x04\x03\x02\x06\x04\x12\x03U\x08\x10\
    \n\x0c\n\x05\x04\x03\x02\x06\x05\x12\x03U\x11\x16\n\x0c\n\x05\x04\x03\
    \x02\x06\x01\x12\x03U\x17#\n\x0c\n\x05\x04\x03\x02\x06\x03\x12\x03U&'\n\
    \x0c\n\x05\x04\x03\x02\x06\x08\x12\x03U(5\n\x0c\n\x05\x04\x03\x02\x06\
    \x07\x12\x03U34\n\x0b\n\x04\x04\x03\x02\x07\x12\x03V\x08:\n\x0c\n\x05\
    \x04\x03\x02\x07\x04\x12\x03V\x08\x10\n\x0c\n\x05\x04\x03\x02\x07\x05\
    \x12\x03V\x11\x16\n\x0c\n\x05\x04\x03\x02\x07\x01\x12\x03V\x17'\n\x0c\n\
    \x05\x04\x03\x02\x07\x03\x12\x03V*+\n\x0c\n\x05\x04\x03\x02\x07\x08\x12\
    \x03V,9\n\x0c\n\x05\x04\x03\x02\x07\x07\x12\x03V78\n\x0b\n\x04\x04\x03\
    \x02\x08\x12\x03W\x08!\n\x0c\n\x05\x04\x03\x02\x08\x04\x12\x03W\x08\x10\
    \n\x0c\n\x05\x04\x03\x02\x08\x05\x12\x03W\x11\x15\n\x0c\n\x05\x04\x03\
    \x02\x08\x01\x12\x03W\x16\x1c\n\x0c\n\x05\x04\x03\x02\x08\x03\x12\x03W\
    \x1f\x20\n\x0b\n\x04\x04\x03\x02\t\x12\x03X\x08+\n\x0c\n\x05\x04\x03\x02\
    \t\x04\x12\x03X\x08\x10\n\x0c\n\x05\x04\x03\x02\t\x05\x12\x03X\x11\x15\n\
    \x0c\n\x05\x04\x03\x02\t\x01\x12\x03X\x16%\n\x0c\n\x05\x04\x03\x02\t\x03\
    \x12\x03X(*\n\n\n\x02\x04\x04\x12\x04[\0x\x01\n\n\n\x03\x04\x04\x01\x12\
    \x03[\x08\x20\n\x0c\n\x04\x04\x04\x03\0\x12\x04\\\x08l\t\n\x0c\n\x05\x04\
    \x04\x03\0\x01\x12\x03\\\x10\x17\n\r\n\x06\x04\x04\x03\0\x02\0\x12\x03]\
    \x10)\n\x0e\n\x07\x04\x04\x03\0\x02\0\x04\x12\x03]\x10\x18\n\x0e\n\x07\
    \x04\x04\x03\0\x02\0\x05\x12\x03]\x19\x1f\n\x0e\n\x07\x04\x04\x03\0\x02\
    \0\x01\x12\x03]\x20$\n\x0e\n\x07\x04\x04\x03\0\x02\0\x03\x12\x03]'(\n\r\
    \n\x06\x04\x04\x03\0\x02\x01\x12\x03^\x10)\n\x0e\n\x07\x04\x04\x03\0\x02\
    \x01\x04\x12\x03^\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\x01\x05\x12\x03^\
    \x19\x1f\n\x0e\n\x07\x04\x04\x03\0\x02\x01\x01\x12\x03^\x20$\n\x0e\n\x07\
    \x04\x04\x03\0\x02\x01\x03\x12\x03^'(\n\r\n\x06\x04\x04\x03\0\x02\x02\
    \x12\x03_\x100\n\x0e\n\x07\x04\x04\x03\0\x02\x02\x04\x12\x03_\x10\x18\n\
    \x0e\n\x07\x04\x04\x03\0\x02\x02\x05\x12\x03_\x19\x1e\n\x0e\n\x07\x04\
    \x04\x03\0\x02\x02\x01\x12\x03_\x1f+\n\x0e\n\x07\x04\x04\x03\0\x02\x02\
    \x03\x12\x03_./\n\r\n\x06\x04\x04\x03\0\x02\x03\x12\x03`\x10.\n\x0e\n\
    \x07\x04\x04\x03\0\x02\x03\x04\x12\x03`\x10\x18\n\x0e\n\x07\x04\x04\x03\
    \0\x02\x03\x05\x12\x03`\x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x03\x01\
    \x12\x03`\x1f)\n\x0e\n\x07\x04\x04\x03\0\x02\x03\x03\x12\x03`,-\n\r\n\
    \x06\x04\x04\x03\0\x02\x04\x12\x03a\x101\n\x0e\n\x07\x04\x04\x03\0\x02\
    \x04\x04\x12\x03a\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\x04\x05\x12\x03a\
    \x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x04\x01\x12\x03a\x1f,\n\x0e\n\x07\
    \x04\x04\x03\0\x02\x04\x03\x12\x03a/0\n\r\n\x06\x04\x04\x03\0\x02\x05\
    \x12\x03b\x102\n\x0e\n\x07\x04\x04\x03\0\x02\x05\x04\x12\x03b\x10\x18\n\
    \x0e\n\x07\x04\x04\x03\0\x02\x05\x05\x12\x03b\x19\x1e\n\x0e\n\x07\x04\
    \x04\x03\0\x02\x05\x01\x12\x03b\x1f-\n\x0e\n\x07\x04\x04\x03\0\x02\x05\
    \x03\x12\x03b01\n\r\n\x06\x04\x04\x03\0\x02\x06\x12\x03c\x103\n\x0e\n\
    \x07\x04\x04\x03\0\x02\x06\x04\x12\x03c\x10\x18\n\x0e\n\x07\x04\x04\x03\
    \0\x02\x06\x05\x12\x03c\x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x06\x01\
    \x12\x03c\x1f.\n\x0e\n\x07\x04\x04\x03\0\x02\x06\x03\x12\x03c12\n\r\n\
    \x06\x04\x04\x03\0\x02\x07\x12\x03d\x100\n\x0e\n\x07\x04\x04\x03\0\x02\
    \x07\x04\x12\x03d\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\x07\x05\x12\x03d\
    \x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x07\x01\x12\x03d\x1f+\n\x0e\n\x07\
    \x04\x04\x03\0\x02\x07\x03\x12\x03d./\n\r\n\x06\x04\x04\x03\0\x02\x08\
    \x12\x03e\x104\n\x0e\n\x07\x04\x04\x03\0\x02\x08\x04\x12\x03e\x10\x18\n\
    \x0e\n\x07\x04\x04\x03\0\x02\x08\x05\x12\x03e\x19\x1f\n\x0e\n\x07\x04\
    \x04\x03\0\x02\x08\x01\x12\x03e\x20/\n\x0e\n\x07\x04\x04\x03\0\x02\x08\
    \x03\x12\x03e23\n\r\n\x06\x04\x04\x03\0\x02\t\x12\x03f\x105\n\x0e\n\x07\
    \x04\x04\x03\0\x02\t\x04\x12\x03f\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\
    \t\x05\x12\x03f\x19\x1f\n\x0e\n\x07\x04\x04\x03\0\x02\t\x01\x12\x03f\x20\
    /\n\x0e\n\x07\x04\x04\x03\0\x02\t\x03\x12\x03f24\n\r\n\x06\x04\x04\x03\0\
    \x02\n\x12\x03g\x100\n\x0e\n\x07\x04\x04\x03\0\x02\n\x04\x12\x03g\x10\
    \x18\n\x0e\n\x07\x04\x04\x03\0\x02\n\x05\x12\x03g\x19\x1d\n\x0e\n\x07\
    \x04\x04\x03\0\x02\n\x01\x12\x03g\x1e*\n\x0e\n\x07\x04\x04\x03\0\x02\n\
    \x03\x12\x03g-/\n\r\n\x06\x04\x04\x03\0\x02\x0b\x12\x03h\x10E\n\x0e\n\
    \x07\x04\x04\x03\0\x02\x0b\x04\x12\x03h\x10\x18\n\x0e\n\x07\x04\x04\x03\
    \0\x02\x0b\x05\x12\x03h\x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x0b\x01\
    \x12\x03h\x1f?\n\x0e\n\x07\x04\x04\x03\0\x02\x0b\x03\x12\x03hBD\n\r\n\
    \x06\x04\x04\x03\0\x02\x0c\x12\x03i\x104\n\x0e\n\x07\x04\x04\x03\0\x02\
    \x0c\x04\x12\x03i\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\x0c\x05\x12\x03i\
    \x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x0c\x01\x12\x03i\x1f.\n\x0e\n\x07\
    \x04\x04\x03\0\x02\x0c\x03\x12\x03i13\n\r\n\x06\x04\x04\x03\0\x02\r\x12\
    \x03j\x102\n\x0e\n\x07\x04\x04\x03\0\x02\r\x04\x12\x03j\x10\x18\n\x0e\n\
    \x07\x04\x04\x03\0\x02\r\x05\x12\x03j\x19\x1e\n\x0e\n\x07\x04\x04\x03\0\
    \x02\r\x01\x12\x03j\x1f,\n\x0e\n\x07\x04\x04\x03\0\x02\r\x03\x12\x03j/1\
    \n\r\n\x06\x04\x04\x03\0\x02\x0e\x12\x03k\x104\n\x0e\n\x07\x04\x04\x03\0\
    \x02\x0e\x04\x12\x03k\x10\x18\n\x0e\n\x07\x04\x04\x03\0\x02\x0e\x05\x12\
    \x03k\x19\x1e\n\x0e\n\x07\x04\x04\x03\0\x02\x0e\x01\x12\x03k\x1f.\n\x0e\
    \n\x07\x04\x04\x03\0\x02\x0e\x03\x12\x03k13\n\x0c\n\x04\x04\x04\x03\x01\
    \x12\x04n\x08s\t\n\x0c\n\x05\x04\x04\x03\x01\x01\x12\x03n\x10\x19\n\r\n\
    \x06\x04\x04\x03\x01\x02\0\x12\x03o\x10&\n\x0e\n\x07\x04\x04\x03\x01\x02\
    \0\x04\x12\x03o\x10\x18\n\x0e\n\x07\x04\x04\x03\x01\x02\0\x05\x12\x03o\
    \x19\x1e\n\x0e\n\x07\x04\x04\x03\x01\x02\0\x01\x12\x03o\x1f!\n\x0e\n\x07\
    \x04\x04\x03\x01\x02\0\x03\x12\x03o$%\n\r\n\x06\x04\x04\x03\x01\x02\x01\
    \x12\x03p\x10-\n\x0e\n\x07\x04\x04\x03\x01\x02\x01\x04\x12\x03p\x10\x18\
    \n\x0e\n\x07\x04\x04\x03\x01\x02\x01\x05\x12\x03p\x19\x1e\n\x0e\n\x07\
    \x04\x04\x03\x01\x02\x01\x01\x12\x03p\x1f(\n\x0e\n\x07\x04\x04\x03\x01\
    \x02\x01\x03\x12\x03p+,\n\r\n\x06\x04\x04\x03\x01\x02\x02\x12\x03q\x10)\
    \n\x0e\n\x07\x04\x04\x03\x01\x02\x02\x04\x12\x03q\x10\x18\n\x0e\n\x07\
    \x04\x04\x03\x01\x02\x02\x05\x12\x03q\x19\x1f\n\x0e\n\x07\x04\x04\x03\
    \x01\x02\x02\x01\x12\x03q\x20$\n\x0e\n\x07\x04\x04\x03\x01\x02\x02\x03\
    \x12\x03q'(\n\r\n\x06\x04\x04\x03\x01\x02\x03\x12\x03r\x10H\n\x0e\n\x07\
    \x04\x04\x03\x01\x02\x03\x04\x12\x03r\x10\x18\n\x0e\n\x07\x04\x04\x03\
    \x01\x02\x03\x06\x12\x03r\x19:\n\x0e\n\x07\x04\x04\x03\x01\x02\x03\x01\
    \x12\x03r;C\n\x0e\n\x07\x04\x04\x03\x01\x02\x03\x03\x12\x03rFG\n\x0b\n\
    \x04\x04\x04\x02\0\x12\x03u\x08!\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03u\
    \x08\x10\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03u\x11\x17\n\x0c\n\x05\x04\
    \x04\x02\0\x01\x12\x03u\x18\x1c\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03u\
    \x1f\x20\n\x0b\n\x04\x04\x04\x02\x01\x12\x03v\x08D\n\x0c\n\x05\x04\x04\
    \x02\x01\x04\x12\x03v\x08\x10\n\x0c\n\x05\x04\x04\x02\x01\x06\x12\x03v\
    \x114\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03v5?\n\x0c\n\x05\x04\x04\x02\
    \x01\x03\x12\x03vBC\n\x0b\n\x04\x04\x04\x02\x02\x12\x03w\x08U\n\x0c\n\
    \x05\x04\x04\x02\x02\x04\x12\x03w\x08\x10\n\x0c\n\x05\x04\x04\x02\x02\
    \x06\x12\x03w\x11\x1c\n\x0c\n\x05\x04\x04\x02\x02\x01\x12\x03w\x1d/\n\
    \x0c\n\x05\x04\x04\x02\x02\x03\x12\x03w23\n\x0c\n\x05\x04\x04\x02\x02\
    \x08\x12\x03w4T\n\x0c\n\x05\x04\x04\x02\x02\x07\x12\x03w?S\n\x0b\n\x02\
    \x04\x05\x12\x05z\0\x81\x01\x01\n\n\n\x03\x04\x05\x01\x12\x03z\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\x1f\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&\n\x0c\n\x05\x04\x05\x02\x03\x03\x12\x03~)\
    *\n\x0b\n\x04\x04\x05\x02\x04\x12\x03\x7f\x086\n\x0c\n\x05\x04\x05\x02\
    \x04\x04\x12\x03\x7f\x08\x10\n\x0c\n\x05\x04\x05\x02\x04\x06\x12\x03\x7f\
    \x11*\n\x0c\n\x05\x04\x05\x02\x04\x01\x12\x03\x7f+1\n\x0c\n\x05\x04\x05\
    \x02\x04\x03\x12\x03\x7f45\n\x0c\n\x04\x04\x05\x02\x05\x12\x04\x80\x01\
    \x088\n\r\n\x05\x04\x05\x02\x05\x04\x12\x04\x80\x01\x08\x10\n\r\n\x05\
    \x04\x05\x02\x05\x06\x12\x04\x80\x01\x11+\n\r\n\x05\x04\x05\x02\x05\x01\
    \x12\x04\x80\x01,3\n\r\n\x05\x04\x05\x02\x05\x03\x12\x04\x80\x0167\n\x0c\
    \n\x02\x04\x06\x12\x06\x83\x01\0\x89\x01\x01\n\x0b\n\x03\x04\x06\x01\x12\
    \x04\x83\x01\x08&\n\x0c\n\x04\x04\x06\x02\0\x12\x04\x84\x01\x08+\n\r\n\
    \x05\x04\x06\x02\0\x04\x12\x04\x84\x01\x08\x10\n\r\n\x05\x04\x06\x02\0\
    \x05\x12\x04\x84\x01\x11\x15\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\x84\x01\
    \x16&\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\x84\x01)*\n\x0c\n\x04\x04\x06\
    \x02\x01\x12\x04\x85\x01\x08=\n\r\n\x05\x04\x06\x02\x01\x04\x12\x04\x85\
    \x01\x08\x10\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\x85\x01\x11\x15\n\r\n\
    \x05\x04\x06\x02\x01\x01\x12\x04\x85\x01\x16'\n\r\n\x05\x04\x06\x02\x01\
    \x03\x12\x04\x85\x01*+\n\r\n\x05\x04\x06\x02\x01\x08\x12\x04\x85\x01,<\n\
    \r\n\x05\x04\x06\x02\x01\x07\x12\x04\x85\x017;\n\x0c\n\x04\x04\x06\x02\
    \x02\x12\x04\x86\x01\x08=\n\r\n\x05\x04\x06\x02\x02\x04\x12\x04\x86\x01\
    \x08\x10\n\r\n\x05\x04\x06\x02\x02\x05\x12\x04\x86\x01\x11\x15\n\r\n\x05\
    \x04\x06\x02\x02\x01\x12\x04\x86\x01\x16'\n\r\n\x05\x04\x06\x02\x02\x03\
    \x12\x04\x86\x01*+\n\r\n\x05\x04\x06\x02\x02\x08\x12\x04\x86\x01,<\n\r\n\
    \x05\x04\x06\x02\x02\x07\x12\x04\x86\x017;\n\x0c\n\x04\x04\x06\x02\x03\
    \x12\x04\x87\x01\x08:\n\r\n\x05\x04\x06\x02\x03\x04\x12\x04\x87\x01\x08\
    \x10\n\r\n\x05\x04\x06\x02\x03\x05\x12\x04\x87\x01\x11\x15\n\r\n\x05\x04\
    \x06\x02\x03\x01\x12\x04\x87\x01\x16$\n\r\n\x05\x04\x06\x02\x03\x03\x12\
    \x04\x87\x01'(\n\r\n\x05\x04\x06\x02\x03\x08\x12\x04\x87\x01)9\n\r\n\x05\
    \x04\x06\x02\x03\x07\x12\x04\x87\x0148\n\x0c\n\x04\x04\x06\x02\x04\x12\
    \x04\x88\x01\x08-\n\r\n\x05\x04\x06\x02\x04\x04\x12\x04\x88\x01\x08\x10\
    \n\r\n\x05\x04\x06\x02\x04\x05\x12\x04\x88\x01\x11\x15\n\r\n\x05\x04\x06\
    \x02\x04\x01\x12\x04\x88\x01\x16(\n\r\n\x05\x04\x06\x02\x04\x03\x12\x04\
    \x88\x01+,\
";

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