app/keymint/keymaster_attributes.rs

// This file is generated by rust-protobuf 2.27.1. Do not edit
// @generated
// Generate steps:
// 1. protoc --rust_out . ../keymaster/keymaster_attributes.proto

// 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 `keymaster_attributes.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1;

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

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

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

    // optional bytes uuid = 1;


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

    pub fn has_uuid(&self) -> bool {
        self.uuid.is_some()
    }

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

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

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

    // optional bytes product_id = 2;


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

    pub fn has_product_id(&self) -> bool {
        self.product_id.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.uuid)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.product_id)?;
                },
                _ => {
                    ::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.uuid.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.product_id.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct AttestationIds {
    // message fields
    brand: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    device: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    product: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    serial: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    imei: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    meid: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    manufacturer: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    model: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    second_imei: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes brand = 1;


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

    pub fn has_brand(&self) -> bool {
        self.brand.is_some()
    }

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

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

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

    // optional bytes device = 2;


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

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

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

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

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

    // optional bytes product = 3;


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

    pub fn has_product(&self) -> bool {
        self.product.is_some()
    }

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

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

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

    // optional bytes serial = 4;


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

    pub fn has_serial(&self) -> bool {
        self.serial.is_some()
    }

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

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

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

    // optional bytes imei = 5;


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

    pub fn has_imei(&self) -> bool {
        self.imei.is_some()
    }

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

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

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

    // optional bytes meid = 6;


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

    pub fn has_meid(&self) -> bool {
        self.meid.is_some()
    }

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

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

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

    // optional bytes manufacturer = 7;


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

    pub fn has_manufacturer(&self) -> bool {
        self.manufacturer.is_some()
    }

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

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

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

    // optional bytes model = 8;


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

    pub fn has_model(&self) -> bool {
        self.model.is_some()
    }

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

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

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

    // optional bytes second_imei = 9;


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

    pub fn has_second_imei(&self) -> bool {
        self.second_imei.is_some()
    }

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.brand)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.device)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.product)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.serial)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.imei)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.meid)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.manufacturer)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.model)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.second_imei)?;
                },
                _ => {
                    ::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.brand.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(ref v) = self.device.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(ref v) = self.product.as_ref() {
            my_size += ::protobuf::rt::bytes_size(3, &v);
        }
        if let Some(ref v) = self.serial.as_ref() {
            my_size += ::protobuf::rt::bytes_size(4, &v);
        }
        if let Some(ref v) = self.imei.as_ref() {
            my_size += ::protobuf::rt::bytes_size(5, &v);
        }
        if let Some(ref v) = self.meid.as_ref() {
            my_size += ::protobuf::rt::bytes_size(6, &v);
        }
        if let Some(ref v) = self.manufacturer.as_ref() {
            my_size += ::protobuf::rt::bytes_size(7, &v);
        }
        if let Some(ref v) = self.model.as_ref() {
            my_size += ::protobuf::rt::bytes_size(8, &v);
        }
        if let Some(ref v) = self.second_imei.as_ref() {
            my_size += ::protobuf::rt::bytes_size(9, &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.brand.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(ref v) = self.device.as_ref() {
            os.write_bytes(2, &v)?;
        }
        if let Some(ref v) = self.product.as_ref() {
            os.write_bytes(3, &v)?;
        }
        if let Some(ref v) = self.serial.as_ref() {
            os.write_bytes(4, &v)?;
        }
        if let Some(ref v) = self.imei.as_ref() {
            os.write_bytes(5, &v)?;
        }
        if let Some(ref v) = self.meid.as_ref() {
            os.write_bytes(6, &v)?;
        }
        if let Some(ref v) = self.manufacturer.as_ref() {
            os.write_bytes(7, &v)?;
        }
        if let Some(ref v) = self.model.as_ref() {
            os.write_bytes(8, &v)?;
        }
        if let Some(ref v) = self.second_imei.as_ref() {
            os.write_bytes(9, &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() -> AttestationIds {
        AttestationIds::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "brand",
                |m: &AttestationIds| { &m.brand },
                |m: &mut AttestationIds| { &mut m.brand },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "device",
                |m: &AttestationIds| { &m.device },
                |m: &mut AttestationIds| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "product",
                |m: &AttestationIds| { &m.product },
                |m: &mut AttestationIds| { &mut m.product },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "serial",
                |m: &AttestationIds| { &m.serial },
                |m: &mut AttestationIds| { &mut m.serial },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "imei",
                |m: &AttestationIds| { &m.imei },
                |m: &mut AttestationIds| { &mut m.imei },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "meid",
                |m: &AttestationIds| { &m.meid },
                |m: &mut AttestationIds| { &mut m.meid },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "manufacturer",
                |m: &AttestationIds| { &m.manufacturer },
                |m: &mut AttestationIds| { &mut m.manufacturer },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "model",
                |m: &AttestationIds| { &m.model },
                |m: &mut AttestationIds| { &mut m.model },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "second_imei",
                |m: &AttestationIds| { &m.second_imei },
                |m: &mut AttestationIds| { &mut m.second_imei },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<AttestationIds>(
                "AttestationIds",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for AttestationIds {
    fn clear(&mut self) {
        self.brand.clear();
        self.device.clear();
        self.product.clear();
        self.serial.clear();
        self.imei.clear();
        self.meid.clear();
        self.manufacturer.clear();
        self.model.clear();
        self.second_imei.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct AttestationKey {
    // message fields
    key: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    pub certs: ::protobuf::RepeatedField<AttestationCert>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bytes key = 1;


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

    pub fn has_key(&self) -> bool {
        self.key.is_some()
    }

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

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

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

    // repeated .AttestationCert certs = 2;


    pub fn get_certs(&self) -> &[AttestationCert] {
        &self.certs
    }
    pub fn clear_certs(&mut self) {
        self.certs.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_certs(&mut self) -> &mut ::protobuf::RepeatedField<AttestationCert> {
        &mut self.certs
    }

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

impl ::protobuf::Message for AttestationKey {
    fn is_initialized(&self) -> bool {
        for v in &self.certs {
            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_bytes_into(wire_type, is, &mut self.key)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.certs)?;
                },
                _ => {
                    ::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.key.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        for value in &self.certs {
            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(ref v) = self.key.as_ref() {
            os.write_bytes(1, &v)?;
        }
        for v in &self.certs {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // required bytes content = 1;


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

    pub fn has_content(&self) -> bool {
        self.content.is_some()
    }

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

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

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

impl ::protobuf::Message for AttestationCert {
    fn is_initialized(&self) -> bool {
        if self.content.is_none() {
            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_bytes_into(wire_type, is, &mut self.content)?;
                },
                _ => {
                    ::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.content.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // repeated .AttestationCert certs = 1;


    pub fn get_certs(&self) -> &[AttestationCert] {
        &self.certs
    }
    pub fn clear_certs(&mut self) {
        self.certs.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_certs(&mut self) -> &mut ::protobuf::RepeatedField<AttestationCert> {
        &mut self.certs
    }

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

impl ::protobuf::Message for UdsCerts {
    fn is_initialized(&self) -> bool {
        for v in &self.certs {
            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.certs)?;
                },
                _ => {
                    ::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.certs {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.certs {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1akeymaster_attributes.proto\x1a\x0cnanopb.proto\"V\n\x13KeymasterAt\
    tributes\x12\x19\n\x04uuid\x18\x01\x20\x01(\x0cR\x04uuidB\x05\x92?\x02\
    \x08\x20\x12$\n\nproduct_id\x18\x02\x20\x01(\x0cR\tproductIdB\x05\x92?\
    \x02\x08\x10\"\xb2\x02\n\x0eAttestationIds\x12\x1b\n\x05brand\x18\x01\
    \x20\x01(\x0cR\x05brandB\x05\x92?\x02\x08@\x12\x1d\n\x06device\x18\x02\
    \x20\x01(\x0cR\x06deviceB\x05\x92?\x02\x08@\x12\x1f\n\x07product\x18\x03\
    \x20\x01(\x0cR\x07productB\x05\x92?\x02\x08@\x12\x1d\n\x06serial\x18\x04\
    \x20\x01(\x0cR\x06serialB\x05\x92?\x02\x08@\x12\x19\n\x04imei\x18\x05\
    \x20\x01(\x0cR\x04imeiB\x05\x92?\x02\x08@\x12\x19\n\x04meid\x18\x06\x20\
    \x01(\x0cR\x04meidB\x05\x92?\x02\x08@\x12)\n\x0cmanufacturer\x18\x07\x20\
    \x01(\x0cR\x0cmanufacturerB\x05\x92?\x02\x08@\x12\x1b\n\x05model\x18\x08\
    \x20\x01(\x0cR\x05modelB\x05\x92?\x02\x08@\x12&\n\x0bsecond_imei\x18\t\
    \x20\x01(\x0cR\nsecondImeiB\x05\x92?\x02\x08@\"Y\n\x0eAttestationKey\x12\
    \x18\n\x03key\x18\x01\x20\x01(\x0cR\x03keyB\x06\x92?\x03\x08\x80\x10\x12\
    -\n\x05certs\x18\x02\x20\x03(\x0b2\x10.AttestationCertR\x05certsB\x05\
    \x92?\x02\x10\x03\"3\n\x0fAttestationCert\x12\x20\n\x07content\x18\x01\
    \x20\x02(\x0cR\x07contentB\x06\x92?\x03\x08\x80\x10\"9\n\x08UdsCerts\x12\
    -\n\x05certs\x18\x01\x20\x03(\x0b2\x10.AttestationCertR\x05certsB\x05\
    \x92?\x02\x10\x03J\x90\x19\n\x06\x12\x04%\0E\x02\n\xa6\x0c\n\x01\x0c\x12\
    \x03%\0\x122\xcc\x04\n\x20Copyright\x20(C)\x202018\x20The\x20Android\x20\
    Open\x20Source\x20Project\n\n\x20Licensed\x20under\x20the\x20Apache\x20L\
    icense,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20no\
    t\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\
    \x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20Lice\
    nse\x20at\n\n\x20\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICE\
    NSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20ag\
    reed\x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20th\
    e\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\
    \n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\
    \x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20fo\
    r\x20the\x20specific\x20language\x20governing\x20permissions\x20and\n\
    \x20limitations\x20under\x20the\x20License.\n2\xcc\x07\x20We\x20check\
    \x20in\x20the\x20prebuilt\x20nanopb\x20protobuf\x20file\x20under\x20the\
    \x20current\x20folder\n\x20because\x20the\x20compile\x20tool\x20chain\
    \x20using\x20trusty/user/base/make/compile_proto.mk\n\x20might\x20not\
    \x20work\x20under\x20certain\x20environment\x20with\x20lower\x20version\
    \x20of\x20python\n\x20protobuf\x20installed.\x20You\x20need\x20to\x20gen\
    erate\x20and\x20check\x20in\x20the\x20new\x20protobuf\x20file\n\x20if\
    \x20you\x20change\x20this\x20file\x20in\x20order\x20for\x20the\x20change\
    \x20to\x20take\x20effect!\n\n\x20To\x20generate\x20the\x20file\x20using\
    \x20the\x20tool\x20chain\x20in\x20trusty\x20tree,\x20add\x20the\x20follo\
    wing\n\x20command\x20to\x20rules.mk:\n\n\x20PB_GEN_DIR\x20:=\x20[Your\
    \x20generation\x20folder]\n\x20include\x20trusty/user/base/make/compile_\
    proto.mk\n\x20$(eval\x20$(call\x20compile_proto,$(KEYMASTER_DIR)/keymast\
    er_attributes.proto,$(PB_GEN_DIR)))\n\n\x20The\x20generated\x20.pb.c\x20\
    and\x20.pb.h\x20file\x20would\x20be\x20under\x20PB_GEN_DIR,\x20include\
    \x20them\n\x20to\x20the\x20source\x20path.\n\n\x20To\x20generate\x20the\
    \x20file\x20using\x20your\x20own\x20tool\x20chain,\x20please\x20follow\
    \x20the\x20guide\x20at\n\x20https://github.com/nanopb/nanopb.\n\x20Pleas\
    e\x20check\x20the\x20nanopb\x20version\x20in\x20trusty\x20tree\x20at\x20\
    external/nanopb-c\x20to\x20make\n\x20sure\x20you\x20are\x20using\x20the\
    \x20same\x20nanopb\x20version.\n\n\t\n\x02\x03\0\x12\x03'\0\x16\n\n\n\
    \x02\x04\0\x12\x04)\0,\x01\n\n\n\x03\x04\0\x01\x12\x03)\x08\x1b\n\x0b\n\
    \x04\x04\0\x02\0\x12\x03*\x021\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03*\x02\
    \n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03*\x0b\x10\n\x0c\n\x05\x04\0\x02\0\
    \x01\x12\x03*\x11\x15\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03*\x18\x19\n\x0c\
    \n\x05\x04\0\x02\0\x08\x12\x03*\x1a0\n\x0f\n\x08\x04\0\x02\0\x08\xf2\x07\
    \x01\x12\x03*\x1b/\n\x0b\n\x04\x04\0\x02\x01\x12\x03+\x027\n\x0c\n\x05\
    \x04\0\x02\x01\x04\x12\x03+\x02\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03+\
    \x0b\x10\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03+\x11\x1b\n\x0c\n\x05\x04\
    \0\x02\x01\x03\x12\x03+\x1e\x1f\n\x0c\n\x05\x04\0\x02\x01\x08\x12\x03+\
    \x206\n\x0f\n\x08\x04\0\x02\x01\x08\xf2\x07\x01\x12\x03+!5\n\n\n\x02\x04\
    \x01\x12\x04.\08\x01\n\n\n\x03\x04\x01\x01\x12\x03.\x08\x16\n\x0b\n\x04\
    \x04\x01\x02\0\x12\x03/\x044\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03/\x04\
    \x0c\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03/\r\x12\n\x0c\n\x05\x04\x01\
    \x02\0\x01\x12\x03/\x13\x18\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03/\x1b\
    \x1c\n\x0c\n\x05\x04\x01\x02\0\x08\x12\x03/\x1d3\n\x0f\n\x08\x04\x01\x02\
    \0\x08\xf2\x07\x01\x12\x03/\x1e2\n\x0b\n\x04\x04\x01\x02\x01\x12\x030\
    \x045\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x030\x04\x0c\n\x0c\n\x05\x04\
    \x01\x02\x01\x05\x12\x030\r\x12\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x030\
    \x13\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x030\x1c\x1d\n\x0c\n\x05\
    \x04\x01\x02\x01\x08\x12\x030\x1e4\n\x0f\n\x08\x04\x01\x02\x01\x08\xf2\
    \x07\x01\x12\x030\x1f3\n\x0b\n\x04\x04\x01\x02\x02\x12\x031\x046\n\x0c\n\
    \x05\x04\x01\x02\x02\x04\x12\x031\x04\x0c\n\x0c\n\x05\x04\x01\x02\x02\
    \x05\x12\x031\r\x12\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x031\x13\x1a\n\
    \x0c\n\x05\x04\x01\x02\x02\x03\x12\x031\x1d\x1e\n\x0c\n\x05\x04\x01\x02\
    \x02\x08\x12\x031\x1f5\n\x0f\n\x08\x04\x01\x02\x02\x08\xf2\x07\x01\x12\
    \x031\x204\n\x0b\n\x04\x04\x01\x02\x03\x12\x032\x045\n\x0c\n\x05\x04\x01\
    \x02\x03\x04\x12\x032\x04\x0c\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x032\r\
    \x12\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x032\x13\x19\n\x0c\n\x05\x04\
    \x01\x02\x03\x03\x12\x032\x1c\x1d\n\x0c\n\x05\x04\x01\x02\x03\x08\x12\
    \x032\x1e4\n\x0f\n\x08\x04\x01\x02\x03\x08\xf2\x07\x01\x12\x032\x1f3\n\
    \x0b\n\x04\x04\x01\x02\x04\x12\x033\x043\n\x0c\n\x05\x04\x01\x02\x04\x04\
    \x12\x033\x04\x0c\n\x0c\n\x05\x04\x01\x02\x04\x05\x12\x033\r\x12\n\x0c\n\
    \x05\x04\x01\x02\x04\x01\x12\x033\x13\x17\n\x0c\n\x05\x04\x01\x02\x04\
    \x03\x12\x033\x1a\x1b\n\x0c\n\x05\x04\x01\x02\x04\x08\x12\x033\x1c2\n\
    \x0f\n\x08\x04\x01\x02\x04\x08\xf2\x07\x01\x12\x033\x1d1\n\x0b\n\x04\x04\
    \x01\x02\x05\x12\x034\x043\n\x0c\n\x05\x04\x01\x02\x05\x04\x12\x034\x04\
    \x0c\n\x0c\n\x05\x04\x01\x02\x05\x05\x12\x034\r\x12\n\x0c\n\x05\x04\x01\
    \x02\x05\x01\x12\x034\x13\x17\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x034\
    \x1a\x1b\n\x0c\n\x05\x04\x01\x02\x05\x08\x12\x034\x1c2\n\x0f\n\x08\x04\
    \x01\x02\x05\x08\xf2\x07\x01\x12\x034\x1d1\n\x0b\n\x04\x04\x01\x02\x06\
    \x12\x035\x04;\n\x0c\n\x05\x04\x01\x02\x06\x04\x12\x035\x04\x0c\n\x0c\n\
    \x05\x04\x01\x02\x06\x05\x12\x035\r\x12\n\x0c\n\x05\x04\x01\x02\x06\x01\
    \x12\x035\x13\x1f\n\x0c\n\x05\x04\x01\x02\x06\x03\x12\x035\"#\n\x0c\n\
    \x05\x04\x01\x02\x06\x08\x12\x035$:\n\x0f\n\x08\x04\x01\x02\x06\x08\xf2\
    \x07\x01\x12\x035%9\n\x0b\n\x04\x04\x01\x02\x07\x12\x036\x044\n\x0c\n\
    \x05\x04\x01\x02\x07\x04\x12\x036\x04\x0c\n\x0c\n\x05\x04\x01\x02\x07\
    \x05\x12\x036\r\x12\n\x0c\n\x05\x04\x01\x02\x07\x01\x12\x036\x13\x18\n\
    \x0c\n\x05\x04\x01\x02\x07\x03\x12\x036\x1b\x1c\n\x0c\n\x05\x04\x01\x02\
    \x07\x08\x12\x036\x1d3\n\x0f\n\x08\x04\x01\x02\x07\x08\xf2\x07\x01\x12\
    \x036\x1e2\n\x0b\n\x04\x04\x01\x02\x08\x12\x037\x04:\n\x0c\n\x05\x04\x01\
    \x02\x08\x04\x12\x037\x04\x0c\n\x0c\n\x05\x04\x01\x02\x08\x05\x12\x037\r\
    \x12\n\x0c\n\x05\x04\x01\x02\x08\x01\x12\x037\x13\x1e\n\x0c\n\x05\x04\
    \x01\x02\x08\x03\x12\x037!\"\n\x0c\n\x05\x04\x01\x02\x08\x08\x12\x037#9\
    \n\x0f\n\x08\x04\x01\x02\x08\x08\xf2\x07\x01\x12\x037$8\n\n\n\x02\x04\
    \x02\x12\x04:\0=\x01\n\n\n\x03\x04\x02\x01\x12\x03:\x08\x16\n\x0b\n\x04\
    \x04\x02\x02\0\x12\x03;\x022\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03;\x02\
    \n\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03;\x0b\x10\n\x0c\n\x05\x04\x02\
    \x02\0\x01\x12\x03;\x11\x14\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03;\x17\
    \x18\n\x0c\n\x05\x04\x02\x02\0\x08\x12\x03;\x191\n\x0f\n\x08\x04\x02\x02\
    \0\x08\xf2\x07\x01\x12\x03;\x1a0\n\x0b\n\x04\x04\x02\x02\x01\x12\x03<\
    \x02<\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03<\x02\n\n\x0c\n\x05\x04\x02\
    \x02\x01\x06\x12\x03<\x0b\x1a\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03<\
    \x1b\x20\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03<#$\n\x0c\n\x05\x04\x02\
    \x02\x01\x08\x12\x03<%;\n\x0f\n\x08\x04\x02\x02\x01\x08\xf2\x07\x02\x12\
    \x03<&:\n\n\n\x02\x04\x03\x12\x04?\0A\x01\n\n\n\x03\x04\x03\x01\x12\x03?\
    \x08\x17\n\x0b\n\x04\x04\x03\x02\0\x12\x03@\x026\n\x0c\n\x05\x04\x03\x02\
    \0\x04\x12\x03@\x02\n\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03@\x0b\x10\n\
    \x0c\n\x05\x04\x03\x02\0\x01\x12\x03@\x11\x18\n\x0c\n\x05\x04\x03\x02\0\
    \x03\x12\x03@\x1b\x1c\n\x0c\n\x05\x04\x03\x02\0\x08\x12\x03@\x1d5\n\x0f\
    \n\x08\x04\x03\x02\0\x08\xf2\x07\x01\x12\x03@\x1e4\n\n\n\x02\x04\x04\x12\
    \x04C\0E\x01\n\n\n\x03\x04\x04\x01\x12\x03C\x08\x10\n\x0b\n\x04\x04\x04\
    \x02\0\x12\x03D\x02<\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x03D\x02\n\n\x0c\
    \n\x05\x04\x04\x02\0\x06\x12\x03D\x0b\x1a\n\x0c\n\x05\x04\x04\x02\0\x01\
    \x12\x03D\x1b\x20\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03D#$\n\x0c\n\x05\
    \x04\x04\x02\0\x08\x12\x03D%;\n\x0f\n\x08\x04\x04\x02\0\x08\xf2\x07\x02\
    \x12\x03D&:\
";

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