// This file is generated by rust-protobuf 3.6.0. Do not edit
// .proto file is parsed by protoc 3.21.12
// @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(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `plugin.proto`

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

// @@protoc_insertion_point(message:CpuidEntry)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CpuidEntry {
    // message fields
    // @@protoc_insertion_point(field:CpuidEntry.function)
    pub function: u32,
    // @@protoc_insertion_point(field:CpuidEntry.has_index)
    pub has_index: bool,
    // @@protoc_insertion_point(field:CpuidEntry.index)
    pub index: u32,
    // @@protoc_insertion_point(field:CpuidEntry.eax)
    pub eax: u32,
    // @@protoc_insertion_point(field:CpuidEntry.ebx)
    pub ebx: u32,
    // @@protoc_insertion_point(field:CpuidEntry.ecx)
    pub ecx: u32,
    // @@protoc_insertion_point(field:CpuidEntry.edx)
    pub edx: u32,
    // special fields
    // @@protoc_insertion_point(special_field:CpuidEntry.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(7);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "function",
            |m: &CpuidEntry| { &m.function },
            |m: &mut CpuidEntry| { &mut m.function },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "has_index",
            |m: &CpuidEntry| { &m.has_index },
            |m: &mut CpuidEntry| { &mut m.has_index },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "index",
            |m: &CpuidEntry| { &m.index },
            |m: &mut CpuidEntry| { &mut m.index },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "eax",
            |m: &CpuidEntry| { &m.eax },
            |m: &mut CpuidEntry| { &mut m.eax },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ebx",
            |m: &CpuidEntry| { &m.ebx },
            |m: &mut CpuidEntry| { &mut m.ebx },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ecx",
            |m: &CpuidEntry| { &m.ecx },
            |m: &mut CpuidEntry| { &mut m.ecx },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "edx",
            |m: &CpuidEntry| { &m.edx },
            |m: &mut CpuidEntry| { &mut m.edx },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CpuidEntry>(
            "CpuidEntry",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for CpuidEntry {
    const NAME: &'static str = "CpuidEntry";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.function = is.read_uint32()?;
                },
                24 => {
                    self.has_index = is.read_bool()?;
                },
                32 => {
                    self.index = is.read_uint32()?;
                },
                40 => {
                    self.eax = is.read_uint32()?;
                },
                48 => {
                    self.ebx = is.read_uint32()?;
                },
                56 => {
                    self.ecx = is.read_uint32()?;
                },
                64 => {
                    self.edx = is.read_uint32()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.function != 0 {
            my_size += ::protobuf::rt::uint32_size(1, self.function);
        }
        if self.has_index != false {
            my_size += 1 + 1;
        }
        if self.index != 0 {
            my_size += ::protobuf::rt::uint32_size(4, self.index);
        }
        if self.eax != 0 {
            my_size += ::protobuf::rt::uint32_size(5, self.eax);
        }
        if self.ebx != 0 {
            my_size += ::protobuf::rt::uint32_size(6, self.ebx);
        }
        if self.ecx != 0 {
            my_size += ::protobuf::rt::uint32_size(7, self.ecx);
        }
        if self.edx != 0 {
            my_size += ::protobuf::rt::uint32_size(8, self.edx);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.function != 0 {
            os.write_uint32(1, self.function)?;
        }
        if self.has_index != false {
            os.write_bool(3, self.has_index)?;
        }
        if self.index != 0 {
            os.write_uint32(4, self.index)?;
        }
        if self.eax != 0 {
            os.write_uint32(5, self.eax)?;
        }
        if self.ebx != 0 {
            os.write_uint32(6, self.ebx)?;
        }
        if self.ecx != 0 {
            os.write_uint32(7, self.ecx)?;
        }
        if self.edx != 0 {
            os.write_uint32(8, self.edx)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.function = 0;
        self.has_index = false;
        self.index = 0;
        self.eax = 0;
        self.ebx = 0;
        self.ecx = 0;
        self.edx = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static CpuidEntry {
        static instance: CpuidEntry = CpuidEntry {
            function: 0,
            has_index: false,
            index: 0,
            eax: 0,
            ebx: 0,
            ecx: 0,
            edx: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for CpuidEntry {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("CpuidEntry").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for CpuidEntry {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:MainRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct MainRequest {
    // message oneof groups
    pub message: ::std::option::Option<main_request::Message>,
    // special fields
    // @@protoc_insertion_point(special_field:MainRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .MainRequest.Create create = 1;

    pub fn create(&self) -> &main_request::Create {
        match self.message {
            ::std::option::Option::Some(main_request::Message::Create(ref v)) => v,
            _ => <main_request::Create as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_create(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_create(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::Create(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_create(&mut self, v: main_request::Create) {
        self.message = ::std::option::Option::Some(main_request::Message::Create(v))
    }

    // Mutable pointer to the field.
    pub fn mut_create(&mut self) -> &mut main_request::Create {
        if let ::std::option::Option::Some(main_request::Message::Create(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::Create(main_request::Create::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::Create(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_create(&mut self) -> main_request::Create {
        if self.has_create() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::Create(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::Create::new()
        }
    }

    // .MainRequest.Destroy destroy = 2;

    pub fn destroy(&self) -> &main_request::Destroy {
        match self.message {
            ::std::option::Option::Some(main_request::Message::Destroy(ref v)) => v,
            _ => <main_request::Destroy as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_destroy(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_destroy(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::Destroy(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_destroy(&mut self, v: main_request::Destroy) {
        self.message = ::std::option::Option::Some(main_request::Message::Destroy(v))
    }

    // Mutable pointer to the field.
    pub fn mut_destroy(&mut self) -> &mut main_request::Destroy {
        if let ::std::option::Option::Some(main_request::Message::Destroy(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::Destroy(main_request::Destroy::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::Destroy(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_destroy(&mut self) -> main_request::Destroy {
        if self.has_destroy() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::Destroy(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::Destroy::new()
        }
    }

    // .MainRequest.NewConnection new_connection = 3;

    pub fn new_connection(&self) -> &main_request::NewConnection {
        match self.message {
            ::std::option::Option::Some(main_request::Message::NewConnection(ref v)) => v,
            _ => <main_request::NewConnection as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_new_connection(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_new_connection(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::NewConnection(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_new_connection(&mut self, v: main_request::NewConnection) {
        self.message = ::std::option::Option::Some(main_request::Message::NewConnection(v))
    }

    // Mutable pointer to the field.
    pub fn mut_new_connection(&mut self) -> &mut main_request::NewConnection {
        if let ::std::option::Option::Some(main_request::Message::NewConnection(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::NewConnection(main_request::NewConnection::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::NewConnection(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_new_connection(&mut self) -> main_request::NewConnection {
        if self.has_new_connection() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::NewConnection(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::NewConnection::new()
        }
    }

    // .MainRequest.GetShutdownEventfd get_shutdown_eventfd = 4;

    pub fn get_shutdown_eventfd(&self) -> &main_request::GetShutdownEventfd {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(ref v)) => v,
            _ => <main_request::GetShutdownEventfd as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_shutdown_eventfd(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_shutdown_eventfd(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_shutdown_eventfd(&mut self, v: main_request::GetShutdownEventfd) {
        self.message = ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_shutdown_eventfd(&mut self) -> &mut main_request::GetShutdownEventfd {
        if let ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(main_request::GetShutdownEventfd::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_shutdown_eventfd(&mut self) -> main_request::GetShutdownEventfd {
        if self.has_get_shutdown_eventfd() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::GetShutdownEventfd::new()
        }
    }

    // .MainRequest.CheckExtension check_extension = 5;

    pub fn check_extension(&self) -> &main_request::CheckExtension {
        match self.message {
            ::std::option::Option::Some(main_request::Message::CheckExtension(ref v)) => v,
            _ => <main_request::CheckExtension as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_check_extension(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_check_extension(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::CheckExtension(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_check_extension(&mut self, v: main_request::CheckExtension) {
        self.message = ::std::option::Option::Some(main_request::Message::CheckExtension(v))
    }

    // Mutable pointer to the field.
    pub fn mut_check_extension(&mut self) -> &mut main_request::CheckExtension {
        if let ::std::option::Option::Some(main_request::Message::CheckExtension(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::CheckExtension(main_request::CheckExtension::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::CheckExtension(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_check_extension(&mut self) -> main_request::CheckExtension {
        if self.has_check_extension() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::CheckExtension(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::CheckExtension::new()
        }
    }

    // .MainRequest.CpuidRequest get_supported_cpuid = 6;

    pub fn get_supported_cpuid(&self) -> &main_request::CpuidRequest {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(ref v)) => v,
            _ => <main_request::CpuidRequest as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_supported_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_supported_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_supported_cpuid(&mut self, v: main_request::CpuidRequest) {
        self.message = ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_supported_cpuid(&mut self) -> &mut main_request::CpuidRequest {
        if let ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(main_request::CpuidRequest::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_supported_cpuid(&mut self) -> main_request::CpuidRequest {
        if self.has_get_supported_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::CpuidRequest::new()
        }
    }

    // .MainRequest.CpuidRequest get_emulated_cpuid = 7;

    pub fn get_emulated_cpuid(&self) -> &main_request::CpuidRequest {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(ref v)) => v,
            _ => <main_request::CpuidRequest as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_emulated_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_emulated_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_emulated_cpuid(&mut self, v: main_request::CpuidRequest) {
        self.message = ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_emulated_cpuid(&mut self) -> &mut main_request::CpuidRequest {
        if let ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(main_request::CpuidRequest::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_emulated_cpuid(&mut self) -> main_request::CpuidRequest {
        if self.has_get_emulated_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::CpuidRequest::new()
        }
    }

    // .MainRequest.MsrListRequest get_msr_index_list = 8;

    pub fn get_msr_index_list(&self) -> &main_request::MsrListRequest {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetMsrIndexList(ref v)) => v,
            _ => <main_request::MsrListRequest as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_msr_index_list(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_msr_index_list(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetMsrIndexList(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_msr_index_list(&mut self, v: main_request::MsrListRequest) {
        self.message = ::std::option::Option::Some(main_request::Message::GetMsrIndexList(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_msr_index_list(&mut self) -> &mut main_request::MsrListRequest {
        if let ::std::option::Option::Some(main_request::Message::GetMsrIndexList(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetMsrIndexList(main_request::MsrListRequest::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetMsrIndexList(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_msr_index_list(&mut self) -> main_request::MsrListRequest {
        if self.has_get_msr_index_list() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetMsrIndexList(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::MsrListRequest::new()
        }
    }

    // .MainRequest.GetNetConfig get_net_config = 9;

    pub fn get_net_config(&self) -> &main_request::GetNetConfig {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetNetConfig(ref v)) => v,
            _ => <main_request::GetNetConfig as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_net_config(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_net_config(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetNetConfig(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_net_config(&mut self, v: main_request::GetNetConfig) {
        self.message = ::std::option::Option::Some(main_request::Message::GetNetConfig(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_net_config(&mut self) -> &mut main_request::GetNetConfig {
        if let ::std::option::Option::Some(main_request::Message::GetNetConfig(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetNetConfig(main_request::GetNetConfig::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetNetConfig(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_net_config(&mut self) -> main_request::GetNetConfig {
        if self.has_get_net_config() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetNetConfig(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::GetNetConfig::new()
        }
    }

    // .MainRequest.ReserveRange reserve_range = 10;

    pub fn reserve_range(&self) -> &main_request::ReserveRange {
        match self.message {
            ::std::option::Option::Some(main_request::Message::ReserveRange(ref v)) => v,
            _ => <main_request::ReserveRange as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_reserve_range(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_reserve_range(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::ReserveRange(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_reserve_range(&mut self, v: main_request::ReserveRange) {
        self.message = ::std::option::Option::Some(main_request::Message::ReserveRange(v))
    }

    // Mutable pointer to the field.
    pub fn mut_reserve_range(&mut self) -> &mut main_request::ReserveRange {
        if let ::std::option::Option::Some(main_request::Message::ReserveRange(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::ReserveRange(main_request::ReserveRange::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::ReserveRange(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_reserve_range(&mut self) -> main_request::ReserveRange {
        if self.has_reserve_range() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::ReserveRange(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::ReserveRange::new()
        }
    }

    // .MainRequest.SetIrq set_irq = 11;

    pub fn set_irq(&self) -> &main_request::SetIrq {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIrq(ref v)) => v,
            _ => <main_request::SetIrq as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_irq(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_irq(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIrq(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_irq(&mut self, v: main_request::SetIrq) {
        self.message = ::std::option::Option::Some(main_request::Message::SetIrq(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_irq(&mut self) -> &mut main_request::SetIrq {
        if let ::std::option::Option::Some(main_request::Message::SetIrq(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::SetIrq(main_request::SetIrq::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIrq(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_irq(&mut self) -> main_request::SetIrq {
        if self.has_set_irq() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::SetIrq(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::SetIrq::new()
        }
    }

    // .MainRequest.SetIrqRouting set_irq_routing = 12;

    pub fn set_irq_routing(&self) -> &main_request::SetIrqRouting {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIrqRouting(ref v)) => v,
            _ => <main_request::SetIrqRouting as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_irq_routing(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_irq_routing(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIrqRouting(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_irq_routing(&mut self, v: main_request::SetIrqRouting) {
        self.message = ::std::option::Option::Some(main_request::Message::SetIrqRouting(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_irq_routing(&mut self) -> &mut main_request::SetIrqRouting {
        if let ::std::option::Option::Some(main_request::Message::SetIrqRouting(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::SetIrqRouting(main_request::SetIrqRouting::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIrqRouting(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_irq_routing(&mut self) -> main_request::SetIrqRouting {
        if self.has_set_irq_routing() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::SetIrqRouting(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::SetIrqRouting::new()
        }
    }

    // .MainRequest.GetState get_state = 13;

    pub fn get_state(&self) -> &main_request::GetState {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetState(ref v)) => v,
            _ => <main_request::GetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_state(&mut self, v: main_request::GetState) {
        self.message = ::std::option::Option::Some(main_request::Message::GetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_state(&mut self) -> &mut main_request::GetState {
        if let ::std::option::Option::Some(main_request::Message::GetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetState(main_request::GetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_state(&mut self) -> main_request::GetState {
        if self.has_get_state() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetState(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::GetState::new()
        }
    }

    // .MainRequest.SetState set_state = 14;

    pub fn set_state(&self) -> &main_request::SetState {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetState(ref v)) => v,
            _ => <main_request::SetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_state(&mut self, v: main_request::SetState) {
        self.message = ::std::option::Option::Some(main_request::Message::SetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_state(&mut self) -> &mut main_request::SetState {
        if let ::std::option::Option::Some(main_request::Message::SetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::SetState(main_request::SetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_state(&mut self) -> main_request::SetState {
        if self.has_set_state() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::SetState(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::SetState::new()
        }
    }

    // .MainRequest.SetIdentityMapAddr set_identity_map_addr = 15;

    pub fn set_identity_map_addr(&self) -> &main_request::SetIdentityMapAddr {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(ref v)) => v,
            _ => <main_request::SetIdentityMapAddr as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_identity_map_addr(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_identity_map_addr(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_identity_map_addr(&mut self, v: main_request::SetIdentityMapAddr) {
        self.message = ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_identity_map_addr(&mut self) -> &mut main_request::SetIdentityMapAddr {
        if let ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(main_request::SetIdentityMapAddr::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_identity_map_addr(&mut self) -> main_request::SetIdentityMapAddr {
        if self.has_set_identity_map_addr() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::SetIdentityMapAddr::new()
        }
    }

    // .MainRequest.PauseVcpus pause_vcpus = 16;

    pub fn pause_vcpus(&self) -> &main_request::PauseVcpus {
        match self.message {
            ::std::option::Option::Some(main_request::Message::PauseVcpus(ref v)) => v,
            _ => <main_request::PauseVcpus as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_pause_vcpus(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_pause_vcpus(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::PauseVcpus(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_pause_vcpus(&mut self, v: main_request::PauseVcpus) {
        self.message = ::std::option::Option::Some(main_request::Message::PauseVcpus(v))
    }

    // Mutable pointer to the field.
    pub fn mut_pause_vcpus(&mut self) -> &mut main_request::PauseVcpus {
        if let ::std::option::Option::Some(main_request::Message::PauseVcpus(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::PauseVcpus(main_request::PauseVcpus::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::PauseVcpus(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_pause_vcpus(&mut self) -> main_request::PauseVcpus {
        if self.has_pause_vcpus() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::PauseVcpus(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::PauseVcpus::new()
        }
    }

    // .MainRequest.GetVcpus get_vcpus = 17;

    pub fn get_vcpus(&self) -> &main_request::GetVcpus {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetVcpus(ref v)) => v,
            _ => <main_request::GetVcpus as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_vcpus(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_vcpus(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetVcpus(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_vcpus(&mut self, v: main_request::GetVcpus) {
        self.message = ::std::option::Option::Some(main_request::Message::GetVcpus(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_vcpus(&mut self) -> &mut main_request::GetVcpus {
        if let ::std::option::Option::Some(main_request::Message::GetVcpus(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::GetVcpus(main_request::GetVcpus::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::GetVcpus(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_vcpus(&mut self) -> main_request::GetVcpus {
        if self.has_get_vcpus() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::GetVcpus(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::GetVcpus::new()
        }
    }

    // .MainRequest.Start start = 18;

    pub fn start(&self) -> &main_request::Start {
        match self.message {
            ::std::option::Option::Some(main_request::Message::Start(ref v)) => v,
            _ => <main_request::Start as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_start(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_start(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::Start(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_start(&mut self, v: main_request::Start) {
        self.message = ::std::option::Option::Some(main_request::Message::Start(v))
    }

    // Mutable pointer to the field.
    pub fn mut_start(&mut self) -> &mut main_request::Start {
        if let ::std::option::Option::Some(main_request::Message::Start(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::Start(main_request::Start::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::Start(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_start(&mut self) -> main_request::Start {
        if self.has_start() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::Start(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::Start::new()
        }
    }

    // .MainRequest.SetCallHint set_call_hint = 19;

    pub fn set_call_hint(&self) -> &main_request::SetCallHint {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetCallHint(ref v)) => v,
            _ => <main_request::SetCallHint as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_call_hint(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_call_hint(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetCallHint(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_call_hint(&mut self, v: main_request::SetCallHint) {
        self.message = ::std::option::Option::Some(main_request::Message::SetCallHint(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_call_hint(&mut self) -> &mut main_request::SetCallHint {
        if let ::std::option::Option::Some(main_request::Message::SetCallHint(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::SetCallHint(main_request::SetCallHint::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::SetCallHint(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_call_hint(&mut self) -> main_request::SetCallHint {
        if self.has_set_call_hint() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::SetCallHint(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::SetCallHint::new()
        }
    }

    // .MainRequest.MemoryDirtyLog dirty_log = 101;

    pub fn dirty_log(&self) -> &main_request::MemoryDirtyLog {
        match self.message {
            ::std::option::Option::Some(main_request::Message::DirtyLog(ref v)) => v,
            _ => <main_request::MemoryDirtyLog as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_dirty_log(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_dirty_log(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_request::Message::DirtyLog(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_dirty_log(&mut self, v: main_request::MemoryDirtyLog) {
        self.message = ::std::option::Option::Some(main_request::Message::DirtyLog(v))
    }

    // Mutable pointer to the field.
    pub fn mut_dirty_log(&mut self) -> &mut main_request::MemoryDirtyLog {
        if let ::std::option::Option::Some(main_request::Message::DirtyLog(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_request::Message::DirtyLog(main_request::MemoryDirtyLog::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_request::Message::DirtyLog(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_dirty_log(&mut self) -> main_request::MemoryDirtyLog {
        if self.has_dirty_log() {
            match self.message.take() {
                ::std::option::Option::Some(main_request::Message::DirtyLog(v)) => v,
                _ => panic!(),
            }
        } else {
            main_request::MemoryDirtyLog::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(20);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::Create>(
            "create",
            MainRequest::has_create,
            MainRequest::create,
            MainRequest::mut_create,
            MainRequest::set_create,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::Destroy>(
            "destroy",
            MainRequest::has_destroy,
            MainRequest::destroy,
            MainRequest::mut_destroy,
            MainRequest::set_destroy,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::NewConnection>(
            "new_connection",
            MainRequest::has_new_connection,
            MainRequest::new_connection,
            MainRequest::mut_new_connection,
            MainRequest::set_new_connection,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::GetShutdownEventfd>(
            "get_shutdown_eventfd",
            MainRequest::has_get_shutdown_eventfd,
            MainRequest::get_shutdown_eventfd,
            MainRequest::mut_get_shutdown_eventfd,
            MainRequest::set_get_shutdown_eventfd,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::CheckExtension>(
            "check_extension",
            MainRequest::has_check_extension,
            MainRequest::check_extension,
            MainRequest::mut_check_extension,
            MainRequest::set_check_extension,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::CpuidRequest>(
            "get_supported_cpuid",
            MainRequest::has_get_supported_cpuid,
            MainRequest::get_supported_cpuid,
            MainRequest::mut_get_supported_cpuid,
            MainRequest::set_get_supported_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::CpuidRequest>(
            "get_emulated_cpuid",
            MainRequest::has_get_emulated_cpuid,
            MainRequest::get_emulated_cpuid,
            MainRequest::mut_get_emulated_cpuid,
            MainRequest::set_get_emulated_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::MsrListRequest>(
            "get_msr_index_list",
            MainRequest::has_get_msr_index_list,
            MainRequest::get_msr_index_list,
            MainRequest::mut_get_msr_index_list,
            MainRequest::set_get_msr_index_list,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::GetNetConfig>(
            "get_net_config",
            MainRequest::has_get_net_config,
            MainRequest::get_net_config,
            MainRequest::mut_get_net_config,
            MainRequest::set_get_net_config,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::ReserveRange>(
            "reserve_range",
            MainRequest::has_reserve_range,
            MainRequest::reserve_range,
            MainRequest::mut_reserve_range,
            MainRequest::set_reserve_range,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::SetIrq>(
            "set_irq",
            MainRequest::has_set_irq,
            MainRequest::set_irq,
            MainRequest::mut_set_irq,
            MainRequest::set_set_irq,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::SetIrqRouting>(
            "set_irq_routing",
            MainRequest::has_set_irq_routing,
            MainRequest::set_irq_routing,
            MainRequest::mut_set_irq_routing,
            MainRequest::set_set_irq_routing,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::GetState>(
            "get_state",
            MainRequest::has_get_state,
            MainRequest::get_state,
            MainRequest::mut_get_state,
            MainRequest::set_get_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::SetState>(
            "set_state",
            MainRequest::has_set_state,
            MainRequest::set_state,
            MainRequest::mut_set_state,
            MainRequest::set_set_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::SetIdentityMapAddr>(
            "set_identity_map_addr",
            MainRequest::has_set_identity_map_addr,
            MainRequest::set_identity_map_addr,
            MainRequest::mut_set_identity_map_addr,
            MainRequest::set_set_identity_map_addr,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::PauseVcpus>(
            "pause_vcpus",
            MainRequest::has_pause_vcpus,
            MainRequest::pause_vcpus,
            MainRequest::mut_pause_vcpus,
            MainRequest::set_pause_vcpus,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::GetVcpus>(
            "get_vcpus",
            MainRequest::has_get_vcpus,
            MainRequest::get_vcpus,
            MainRequest::mut_get_vcpus,
            MainRequest::set_get_vcpus,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::Start>(
            "start",
            MainRequest::has_start,
            MainRequest::start,
            MainRequest::mut_start,
            MainRequest::set_start,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::SetCallHint>(
            "set_call_hint",
            MainRequest::has_set_call_hint,
            MainRequest::set_call_hint,
            MainRequest::mut_set_call_hint,
            MainRequest::set_set_call_hint,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_request::MemoryDirtyLog>(
            "dirty_log",
            MainRequest::has_dirty_log,
            MainRequest::dirty_log,
            MainRequest::mut_dirty_log,
            MainRequest::set_dirty_log,
        ));
        oneofs.push(main_request::Message::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MainRequest>(
            "MainRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for MainRequest {
    const NAME: &'static str = "MainRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.message = ::std::option::Option::Some(main_request::Message::Create(is.read_message()?));
                },
                18 => {
                    self.message = ::std::option::Option::Some(main_request::Message::Destroy(is.read_message()?));
                },
                26 => {
                    self.message = ::std::option::Option::Some(main_request::Message::NewConnection(is.read_message()?));
                },
                34 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetShutdownEventfd(is.read_message()?));
                },
                42 => {
                    self.message = ::std::option::Option::Some(main_request::Message::CheckExtension(is.read_message()?));
                },
                50 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetSupportedCpuid(is.read_message()?));
                },
                58 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetEmulatedCpuid(is.read_message()?));
                },
                66 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetMsrIndexList(is.read_message()?));
                },
                74 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetNetConfig(is.read_message()?));
                },
                82 => {
                    self.message = ::std::option::Option::Some(main_request::Message::ReserveRange(is.read_message()?));
                },
                90 => {
                    self.message = ::std::option::Option::Some(main_request::Message::SetIrq(is.read_message()?));
                },
                98 => {
                    self.message = ::std::option::Option::Some(main_request::Message::SetIrqRouting(is.read_message()?));
                },
                106 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetState(is.read_message()?));
                },
                114 => {
                    self.message = ::std::option::Option::Some(main_request::Message::SetState(is.read_message()?));
                },
                122 => {
                    self.message = ::std::option::Option::Some(main_request::Message::SetIdentityMapAddr(is.read_message()?));
                },
                130 => {
                    self.message = ::std::option::Option::Some(main_request::Message::PauseVcpus(is.read_message()?));
                },
                138 => {
                    self.message = ::std::option::Option::Some(main_request::Message::GetVcpus(is.read_message()?));
                },
                146 => {
                    self.message = ::std::option::Option::Some(main_request::Message::Start(is.read_message()?));
                },
                154 => {
                    self.message = ::std::option::Option::Some(main_request::Message::SetCallHint(is.read_message()?));
                },
                810 => {
                    self.message = ::std::option::Option::Some(main_request::Message::DirtyLog(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &main_request::Message::Create(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::Destroy(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::NewConnection(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetShutdownEventfd(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::CheckExtension(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetSupportedCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetEmulatedCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetMsrIndexList(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetNetConfig(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::ReserveRange(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::SetIrq(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::SetIrqRouting(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::SetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::SetIdentityMapAddr(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::PauseVcpus(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::GetVcpus(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::Start(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::SetCallHint(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_request::Message::DirtyLog(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &main_request::Message::Create(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &main_request::Message::Destroy(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &main_request::Message::NewConnection(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &main_request::Message::GetShutdownEventfd(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &main_request::Message::CheckExtension(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &main_request::Message::GetSupportedCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &main_request::Message::GetEmulatedCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &main_request::Message::GetMsrIndexList(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &main_request::Message::GetNetConfig(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                },
                &main_request::Message::ReserveRange(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                },
                &main_request::Message::SetIrq(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
                },
                &main_request::Message::SetIrqRouting(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
                },
                &main_request::Message::GetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
                },
                &main_request::Message::SetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
                },
                &main_request::Message::SetIdentityMapAddr(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
                },
                &main_request::Message::PauseVcpus(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
                },
                &main_request::Message::GetVcpus(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(17, v, os)?;
                },
                &main_request::Message::Start(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
                },
                &main_request::Message::SetCallHint(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
                },
                &main_request::Message::DirtyLog(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(101, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MainRequest {
        static instance: MainRequest = MainRequest {
            message: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for MainRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("MainRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for MainRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `MainRequest`
pub mod main_request {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:MainRequest.message)
    pub enum Message {
        // @@protoc_insertion_point(oneof_field:MainRequest.create)
        Create(Create),
        // @@protoc_insertion_point(oneof_field:MainRequest.destroy)
        Destroy(Destroy),
        // @@protoc_insertion_point(oneof_field:MainRequest.new_connection)
        NewConnection(NewConnection),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_shutdown_eventfd)
        GetShutdownEventfd(GetShutdownEventfd),
        // @@protoc_insertion_point(oneof_field:MainRequest.check_extension)
        CheckExtension(CheckExtension),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_supported_cpuid)
        GetSupportedCpuid(CpuidRequest),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_emulated_cpuid)
        GetEmulatedCpuid(CpuidRequest),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_msr_index_list)
        GetMsrIndexList(MsrListRequest),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_net_config)
        GetNetConfig(GetNetConfig),
        // @@protoc_insertion_point(oneof_field:MainRequest.reserve_range)
        ReserveRange(ReserveRange),
        // @@protoc_insertion_point(oneof_field:MainRequest.set_irq)
        SetIrq(SetIrq),
        // @@protoc_insertion_point(oneof_field:MainRequest.set_irq_routing)
        SetIrqRouting(SetIrqRouting),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_state)
        GetState(GetState),
        // @@protoc_insertion_point(oneof_field:MainRequest.set_state)
        SetState(SetState),
        // @@protoc_insertion_point(oneof_field:MainRequest.set_identity_map_addr)
        SetIdentityMapAddr(SetIdentityMapAddr),
        // @@protoc_insertion_point(oneof_field:MainRequest.pause_vcpus)
        PauseVcpus(PauseVcpus),
        // @@protoc_insertion_point(oneof_field:MainRequest.get_vcpus)
        GetVcpus(GetVcpus),
        // @@protoc_insertion_point(oneof_field:MainRequest.start)
        Start(Start),
        // @@protoc_insertion_point(oneof_field:MainRequest.set_call_hint)
        SetCallHint(SetCallHint),
        // @@protoc_insertion_point(oneof_field:MainRequest.dirty_log)
        DirtyLog(MemoryDirtyLog),
    }

    impl ::protobuf::Oneof for Message {
    }

    impl ::protobuf::OneofFull for Message {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::MainRequest as ::protobuf::MessageFull>::descriptor().oneof_by_name("message").unwrap()).clone()
        }
    }

    impl Message {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Message>("message")
        }
    }
    // @@protoc_insertion_point(message:MainRequest.Create)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Create {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.Create.id)
        pub id: u32,
        // message oneof groups
        pub constructor: ::std::option::Option<create::Constructor>,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.Create.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // .MainRequest.Create.IoEvent io_event = 2;

        pub fn io_event(&self) -> &create::IoEvent {
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::IoEvent(ref v)) => v,
                _ => <create::IoEvent as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_io_event(&mut self) {
            self.constructor = ::std::option::Option::None;
        }

        pub fn has_io_event(&self) -> bool {
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::IoEvent(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_io_event(&mut self, v: create::IoEvent) {
            self.constructor = ::std::option::Option::Some(create::Constructor::IoEvent(v))
        }

        // Mutable pointer to the field.
        pub fn mut_io_event(&mut self) -> &mut create::IoEvent {
            if let ::std::option::Option::Some(create::Constructor::IoEvent(_)) = self.constructor {
            } else {
                self.constructor = ::std::option::Option::Some(create::Constructor::IoEvent(create::IoEvent::new()));
            }
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::IoEvent(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_io_event(&mut self) -> create::IoEvent {
            if self.has_io_event() {
                match self.constructor.take() {
                    ::std::option::Option::Some(create::Constructor::IoEvent(v)) => v,
                    _ => panic!(),
                }
            } else {
                create::IoEvent::new()
            }
        }

        // .MainRequest.Create.Memory memory = 3;

        pub fn memory(&self) -> &create::Memory {
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::Memory(ref v)) => v,
                _ => <create::Memory as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_memory(&mut self) {
            self.constructor = ::std::option::Option::None;
        }

        pub fn has_memory(&self) -> bool {
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::Memory(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_memory(&mut self, v: create::Memory) {
            self.constructor = ::std::option::Option::Some(create::Constructor::Memory(v))
        }

        // Mutable pointer to the field.
        pub fn mut_memory(&mut self) -> &mut create::Memory {
            if let ::std::option::Option::Some(create::Constructor::Memory(_)) = self.constructor {
            } else {
                self.constructor = ::std::option::Option::Some(create::Constructor::Memory(create::Memory::new()));
            }
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::Memory(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_memory(&mut self) -> create::Memory {
            if self.has_memory() {
                match self.constructor.take() {
                    ::std::option::Option::Some(create::Constructor::Memory(v)) => v,
                    _ => panic!(),
                }
            } else {
                create::Memory::new()
            }
        }

        // .MainRequest.Create.IrqEvent irq_event = 4;

        pub fn irq_event(&self) -> &create::IrqEvent {
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::IrqEvent(ref v)) => v,
                _ => <create::IrqEvent as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_irq_event(&mut self) {
            self.constructor = ::std::option::Option::None;
        }

        pub fn has_irq_event(&self) -> bool {
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::IrqEvent(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_irq_event(&mut self, v: create::IrqEvent) {
            self.constructor = ::std::option::Option::Some(create::Constructor::IrqEvent(v))
        }

        // Mutable pointer to the field.
        pub fn mut_irq_event(&mut self) -> &mut create::IrqEvent {
            if let ::std::option::Option::Some(create::Constructor::IrqEvent(_)) = self.constructor {
            } else {
                self.constructor = ::std::option::Option::Some(create::Constructor::IrqEvent(create::IrqEvent::new()));
            }
            match self.constructor {
                ::std::option::Option::Some(create::Constructor::IrqEvent(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_irq_event(&mut self) -> create::IrqEvent {
            if self.has_irq_event() {
                match self.constructor.take() {
                    ::std::option::Option::Some(create::Constructor::IrqEvent(v)) => v,
                    _ => panic!(),
                }
            } else {
                create::IrqEvent::new()
            }
        }

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(4);
            let mut oneofs = ::std::vec::Vec::with_capacity(1);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "id",
                |m: &Create| { &m.id },
                |m: &mut Create| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, create::IoEvent>(
                "io_event",
                Create::has_io_event,
                Create::io_event,
                Create::mut_io_event,
                Create::set_io_event,
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, create::Memory>(
                "memory",
                Create::has_memory,
                Create::memory,
                Create::mut_memory,
                Create::set_memory,
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, create::IrqEvent>(
                "irq_event",
                Create::has_irq_event,
                Create::irq_event,
                Create::mut_irq_event,
                Create::set_irq_event,
            ));
            oneofs.push(create::Constructor::generated_oneof_descriptor_data());
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Create>(
                "MainRequest.Create",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Create {
        const NAME: &'static str = "Create";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.id = is.read_uint32()?;
                    },
                    18 => {
                        self.constructor = ::std::option::Option::Some(create::Constructor::IoEvent(is.read_message()?));
                    },
                    26 => {
                        self.constructor = ::std::option::Option::Some(create::Constructor::Memory(is.read_message()?));
                    },
                    34 => {
                        self.constructor = ::std::option::Option::Some(create::Constructor::IrqEvent(is.read_message()?));
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.id != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.id);
            }
            if let ::std::option::Option::Some(ref v) = self.constructor {
                match v {
                    &create::Constructor::IoEvent(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &create::Constructor::Memory(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &create::Constructor::IrqEvent(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                };
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.id != 0 {
                os.write_uint32(1, self.id)?;
            }
            if let ::std::option::Option::Some(ref v) = self.constructor {
                match v {
                    &create::Constructor::IoEvent(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                    },
                    &create::Constructor::Memory(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                    },
                    &create::Constructor::IrqEvent(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                    },
                };
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.id = 0;
            self.constructor = ::std::option::Option::None;
            self.constructor = ::std::option::Option::None;
            self.constructor = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Create {
            static instance: Create = Create {
                id: 0,
                constructor: ::std::option::Option::None,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Create {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.Create").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Create {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    /// Nested message and enums of message `Create`
    pub mod create {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        // @@protoc_insertion_point(oneof:MainRequest.Create.constructor)
        pub enum Constructor {
            // @@protoc_insertion_point(oneof_field:MainRequest.Create.io_event)
            IoEvent(IoEvent),
            // @@protoc_insertion_point(oneof_field:MainRequest.Create.memory)
            Memory(Memory),
            // @@protoc_insertion_point(oneof_field:MainRequest.Create.irq_event)
            IrqEvent(IrqEvent),
        }

        impl ::protobuf::Oneof for Constructor {
        }

        impl ::protobuf::OneofFull for Constructor {
            fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| <super::Create as ::protobuf::MessageFull>::descriptor().oneof_by_name("constructor").unwrap()).clone()
            }
        }

        impl Constructor {
            pub(in super::super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
                ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Constructor>("constructor")
            }
        }
        // @@protoc_insertion_point(message:MainRequest.Create.IoEvent)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct IoEvent {
            // message fields
            // @@protoc_insertion_point(field:MainRequest.Create.IoEvent.space)
            pub space: ::protobuf::EnumOrUnknown<super::super::AddressSpace>,
            // @@protoc_insertion_point(field:MainRequest.Create.IoEvent.address)
            pub address: u64,
            // @@protoc_insertion_point(field:MainRequest.Create.IoEvent.length)
            pub length: u32,
            // @@protoc_insertion_point(field:MainRequest.Create.IoEvent.datamatch)
            pub datamatch: u64,
            // special fields
            // @@protoc_insertion_point(special_field:MainRequest.Create.IoEvent.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(4);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "space",
                    |m: &IoEvent| { &m.space },
                    |m: &mut IoEvent| { &mut m.space },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "address",
                    |m: &IoEvent| { &m.address },
                    |m: &mut IoEvent| { &mut m.address },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "length",
                    |m: &IoEvent| { &m.length },
                    |m: &mut IoEvent| { &mut m.length },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "datamatch",
                    |m: &IoEvent| { &m.datamatch },
                    |m: &mut IoEvent| { &mut m.datamatch },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IoEvent>(
                    "MainRequest.Create.IoEvent",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for IoEvent {
            const NAME: &'static str = "IoEvent";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.space = is.read_enum_or_unknown()?;
                        },
                        16 => {
                            self.address = is.read_uint64()?;
                        },
                        24 => {
                            self.length = is.read_uint32()?;
                        },
                        32 => {
                            self.datamatch = is.read_uint64()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.space != ::protobuf::EnumOrUnknown::new(super::super::AddressSpace::IOPORT) {
                    my_size += ::protobuf::rt::int32_size(1, self.space.value());
                }
                if self.address != 0 {
                    my_size += ::protobuf::rt::uint64_size(2, self.address);
                }
                if self.length != 0 {
                    my_size += ::protobuf::rt::uint32_size(3, self.length);
                }
                if self.datamatch != 0 {
                    my_size += ::protobuf::rt::uint64_size(4, self.datamatch);
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.space != ::protobuf::EnumOrUnknown::new(super::super::AddressSpace::IOPORT) {
                    os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.space))?;
                }
                if self.address != 0 {
                    os.write_uint64(2, self.address)?;
                }
                if self.length != 0 {
                    os.write_uint32(3, self.length)?;
                }
                if self.datamatch != 0 {
                    os.write_uint64(4, self.datamatch)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.space = ::protobuf::EnumOrUnknown::new(super::super::AddressSpace::IOPORT);
                self.address = 0;
                self.length = 0;
                self.datamatch = 0;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static IoEvent {
                static instance: IoEvent = IoEvent {
                    space: ::protobuf::EnumOrUnknown::from_i32(0),
                    address: 0,
                    length: 0,
                    datamatch: 0,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for IoEvent {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("MainRequest.Create.IoEvent").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for IoEvent {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        // @@protoc_insertion_point(message:MainRequest.Create.Memory)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Memory {
            // message fields
            // @@protoc_insertion_point(field:MainRequest.Create.Memory.offset)
            pub offset: u64,
            // @@protoc_insertion_point(field:MainRequest.Create.Memory.start)
            pub start: u64,
            // @@protoc_insertion_point(field:MainRequest.Create.Memory.length)
            pub length: u64,
            // @@protoc_insertion_point(field:MainRequest.Create.Memory.read_only)
            pub read_only: bool,
            // @@protoc_insertion_point(field:MainRequest.Create.Memory.dirty_log)
            pub dirty_log: bool,
            // special fields
            // @@protoc_insertion_point(special_field:MainRequest.Create.Memory.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(5);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "offset",
                    |m: &Memory| { &m.offset },
                    |m: &mut Memory| { &mut m.offset },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "start",
                    |m: &Memory| { &m.start },
                    |m: &mut Memory| { &mut m.start },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "length",
                    |m: &Memory| { &m.length },
                    |m: &mut Memory| { &mut m.length },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "read_only",
                    |m: &Memory| { &m.read_only },
                    |m: &mut Memory| { &mut m.read_only },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "dirty_log",
                    |m: &Memory| { &m.dirty_log },
                    |m: &mut Memory| { &mut m.dirty_log },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Memory>(
                    "MainRequest.Create.Memory",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for Memory {
            const NAME: &'static str = "Memory";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.offset = is.read_uint64()?;
                        },
                        16 => {
                            self.start = is.read_uint64()?;
                        },
                        24 => {
                            self.length = is.read_uint64()?;
                        },
                        32 => {
                            self.read_only = is.read_bool()?;
                        },
                        40 => {
                            self.dirty_log = is.read_bool()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.offset != 0 {
                    my_size += ::protobuf::rt::uint64_size(1, self.offset);
                }
                if self.start != 0 {
                    my_size += ::protobuf::rt::uint64_size(2, self.start);
                }
                if self.length != 0 {
                    my_size += ::protobuf::rt::uint64_size(3, self.length);
                }
                if self.read_only != false {
                    my_size += 1 + 1;
                }
                if self.dirty_log != false {
                    my_size += 1 + 1;
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.offset != 0 {
                    os.write_uint64(1, self.offset)?;
                }
                if self.start != 0 {
                    os.write_uint64(2, self.start)?;
                }
                if self.length != 0 {
                    os.write_uint64(3, self.length)?;
                }
                if self.read_only != false {
                    os.write_bool(4, self.read_only)?;
                }
                if self.dirty_log != false {
                    os.write_bool(5, self.dirty_log)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.offset = 0;
                self.start = 0;
                self.length = 0;
                self.read_only = false;
                self.dirty_log = false;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Memory {
                static instance: Memory = Memory {
                    offset: 0,
                    start: 0,
                    length: 0,
                    read_only: false,
                    dirty_log: false,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for Memory {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("MainRequest.Create.Memory").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for Memory {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        // @@protoc_insertion_point(message:MainRequest.Create.IrqEvent)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct IrqEvent {
            // message fields
            // @@protoc_insertion_point(field:MainRequest.Create.IrqEvent.irq_id)
            pub irq_id: u32,
            // @@protoc_insertion_point(field:MainRequest.Create.IrqEvent.resample)
            pub resample: bool,
            // special fields
            // @@protoc_insertion_point(special_field:MainRequest.Create.IrqEvent.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(2);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "irq_id",
                    |m: &IrqEvent| { &m.irq_id },
                    |m: &mut IrqEvent| { &mut m.irq_id },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "resample",
                    |m: &IrqEvent| { &m.resample },
                    |m: &mut IrqEvent| { &mut m.resample },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IrqEvent>(
                    "MainRequest.Create.IrqEvent",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for IrqEvent {
            const NAME: &'static str = "IrqEvent";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.irq_id = is.read_uint32()?;
                        },
                        16 => {
                            self.resample = is.read_bool()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.irq_id != 0 {
                    my_size += ::protobuf::rt::uint32_size(1, self.irq_id);
                }
                if self.resample != false {
                    my_size += 1 + 1;
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.irq_id != 0 {
                    os.write_uint32(1, self.irq_id)?;
                }
                if self.resample != false {
                    os.write_bool(2, self.resample)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.irq_id = 0;
                self.resample = false;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static IrqEvent {
                static instance: IrqEvent = IrqEvent {
                    irq_id: 0,
                    resample: false,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for IrqEvent {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("MainRequest.Create.IrqEvent").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for IrqEvent {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }
    }

    // @@protoc_insertion_point(message:MainRequest.Destroy)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Destroy {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.Destroy.id)
        pub id: u32,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.Destroy.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "id",
                |m: &Destroy| { &m.id },
                |m: &mut Destroy| { &mut m.id },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Destroy>(
                "MainRequest.Destroy",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Destroy {
        const NAME: &'static str = "Destroy";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.id = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.id != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.id);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.id != 0 {
                os.write_uint32(1, self.id)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.id = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Destroy {
            static instance: Destroy = Destroy {
                id: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Destroy {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.Destroy").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Destroy {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.NewConnection)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct NewConnection {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.NewConnection.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NewConnection>(
                "MainRequest.NewConnection",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for NewConnection {
        const NAME: &'static str = "NewConnection";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static NewConnection {
            static instance: NewConnection = NewConnection {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for NewConnection {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.NewConnection").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for NewConnection {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.GetShutdownEventfd)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetShutdownEventfd {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.GetShutdownEventfd.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetShutdownEventfd>(
                "MainRequest.GetShutdownEventfd",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetShutdownEventfd {
        const NAME: &'static str = "GetShutdownEventfd";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetShutdownEventfd {
            static instance: GetShutdownEventfd = GetShutdownEventfd {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetShutdownEventfd {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.GetShutdownEventfd").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetShutdownEventfd {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.CheckExtension)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CheckExtension {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.CheckExtension.extension)
        pub extension: u32,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.CheckExtension.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "extension",
                |m: &CheckExtension| { &m.extension },
                |m: &mut CheckExtension| { &mut m.extension },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CheckExtension>(
                "MainRequest.CheckExtension",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for CheckExtension {
        const NAME: &'static str = "CheckExtension";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.extension = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.extension != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.extension);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.extension != 0 {
                os.write_uint32(1, self.extension)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.extension = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static CheckExtension {
            static instance: CheckExtension = CheckExtension {
                extension: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for CheckExtension {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.CheckExtension").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for CheckExtension {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.CpuidRequest)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CpuidRequest {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.CpuidRequest.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CpuidRequest>(
                "MainRequest.CpuidRequest",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for CpuidRequest {
        const NAME: &'static str = "CpuidRequest";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static CpuidRequest {
            static instance: CpuidRequest = CpuidRequest {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for CpuidRequest {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.CpuidRequest").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for CpuidRequest {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.MsrListRequest)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MsrListRequest {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.MsrListRequest.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MsrListRequest>(
                "MainRequest.MsrListRequest",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for MsrListRequest {
        const NAME: &'static str = "MsrListRequest";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static MsrListRequest {
            static instance: MsrListRequest = MsrListRequest {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for MsrListRequest {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.MsrListRequest").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for MsrListRequest {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.GetNetConfig)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetNetConfig {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.GetNetConfig.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetNetConfig>(
                "MainRequest.GetNetConfig",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetNetConfig {
        const NAME: &'static str = "GetNetConfig";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetNetConfig {
            static instance: GetNetConfig = GetNetConfig {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetNetConfig {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.GetNetConfig").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetNetConfig {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.ReserveRange)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ReserveRange {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.ReserveRange.space)
        pub space: ::protobuf::EnumOrUnknown<super::AddressSpace>,
        // @@protoc_insertion_point(field:MainRequest.ReserveRange.start)
        pub start: u64,
        // @@protoc_insertion_point(field:MainRequest.ReserveRange.length)
        pub length: u64,
        // @@protoc_insertion_point(field:MainRequest.ReserveRange.async_write)
        pub async_write: bool,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.ReserveRange.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(4);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "space",
                |m: &ReserveRange| { &m.space },
                |m: &mut ReserveRange| { &mut m.space },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "start",
                |m: &ReserveRange| { &m.start },
                |m: &mut ReserveRange| { &mut m.start },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "length",
                |m: &ReserveRange| { &m.length },
                |m: &mut ReserveRange| { &mut m.length },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "async_write",
                |m: &ReserveRange| { &m.async_write },
                |m: &mut ReserveRange| { &mut m.async_write },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ReserveRange>(
                "MainRequest.ReserveRange",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for ReserveRange {
        const NAME: &'static str = "ReserveRange";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.space = is.read_enum_or_unknown()?;
                    },
                    16 => {
                        self.start = is.read_uint64()?;
                    },
                    24 => {
                        self.length = is.read_uint64()?;
                    },
                    32 => {
                        self.async_write = is.read_bool()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.space != ::protobuf::EnumOrUnknown::new(super::AddressSpace::IOPORT) {
                my_size += ::protobuf::rt::int32_size(1, self.space.value());
            }
            if self.start != 0 {
                my_size += ::protobuf::rt::uint64_size(2, self.start);
            }
            if self.length != 0 {
                my_size += ::protobuf::rt::uint64_size(3, self.length);
            }
            if self.async_write != false {
                my_size += 1 + 1;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.space != ::protobuf::EnumOrUnknown::new(super::AddressSpace::IOPORT) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.space))?;
            }
            if self.start != 0 {
                os.write_uint64(2, self.start)?;
            }
            if self.length != 0 {
                os.write_uint64(3, self.length)?;
            }
            if self.async_write != false {
                os.write_bool(4, self.async_write)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.space = ::protobuf::EnumOrUnknown::new(super::AddressSpace::IOPORT);
            self.start = 0;
            self.length = 0;
            self.async_write = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ReserveRange {
            static instance: ReserveRange = ReserveRange {
                space: ::protobuf::EnumOrUnknown::from_i32(0),
                start: 0,
                length: 0,
                async_write: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for ReserveRange {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.ReserveRange").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for ReserveRange {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.SetIrq)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetIrq {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.SetIrq.irq_id)
        pub irq_id: u32,
        // @@protoc_insertion_point(field:MainRequest.SetIrq.active)
        pub active: bool,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.SetIrq.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(2);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "irq_id",
                |m: &SetIrq| { &m.irq_id },
                |m: &mut SetIrq| { &mut m.irq_id },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "active",
                |m: &SetIrq| { &m.active },
                |m: &mut SetIrq| { &mut m.active },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetIrq>(
                "MainRequest.SetIrq",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetIrq {
        const NAME: &'static str = "SetIrq";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.irq_id = is.read_uint32()?;
                    },
                    16 => {
                        self.active = is.read_bool()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.irq_id != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.irq_id);
            }
            if self.active != false {
                my_size += 1 + 1;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.irq_id != 0 {
                os.write_uint32(1, self.irq_id)?;
            }
            if self.active != false {
                os.write_bool(2, self.active)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.irq_id = 0;
            self.active = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetIrq {
            static instance: SetIrq = SetIrq {
                irq_id: 0,
                active: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetIrq {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.SetIrq").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetIrq {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.SetIrqRouting)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetIrqRouting {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.SetIrqRouting.routes)
        pub routes: ::std::vec::Vec<set_irq_routing::Route>,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.SetIrqRouting.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "routes",
                |m: &SetIrqRouting| { &m.routes },
                |m: &mut SetIrqRouting| { &mut m.routes },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetIrqRouting>(
                "MainRequest.SetIrqRouting",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetIrqRouting {
        const NAME: &'static str = "SetIrqRouting";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.routes.push(is.read_message()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            for value in &self.routes {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            for v in &self.routes {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.routes.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetIrqRouting {
            static instance: SetIrqRouting = SetIrqRouting {
                routes: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetIrqRouting {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.SetIrqRouting").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetIrqRouting {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    /// Nested message and enums of message `SetIrqRouting`
    pub mod set_irq_routing {
        // @@protoc_insertion_point(message:MainRequest.SetIrqRouting.Route)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Route {
            // message fields
            // @@protoc_insertion_point(field:MainRequest.SetIrqRouting.Route.irq_id)
            pub irq_id: u32,
            // message oneof groups
            pub route: ::std::option::Option<route::Route>,
            // special fields
            // @@protoc_insertion_point(special_field:MainRequest.SetIrqRouting.Route.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            // .MainRequest.SetIrqRouting.Route.Irqchip irqchip = 2;

            pub fn irqchip(&self) -> &route::Irqchip {
                match self.route {
                    ::std::option::Option::Some(route::Route::Irqchip(ref v)) => v,
                    _ => <route::Irqchip as ::protobuf::Message>::default_instance(),
                }
            }

            pub fn clear_irqchip(&mut self) {
                self.route = ::std::option::Option::None;
            }

            pub fn has_irqchip(&self) -> bool {
                match self.route {
                    ::std::option::Option::Some(route::Route::Irqchip(..)) => true,
                    _ => false,
                }
            }

            // Param is passed by value, moved
            pub fn set_irqchip(&mut self, v: route::Irqchip) {
                self.route = ::std::option::Option::Some(route::Route::Irqchip(v))
            }

            // Mutable pointer to the field.
            pub fn mut_irqchip(&mut self) -> &mut route::Irqchip {
                if let ::std::option::Option::Some(route::Route::Irqchip(_)) = self.route {
                } else {
                    self.route = ::std::option::Option::Some(route::Route::Irqchip(route::Irqchip::new()));
                }
                match self.route {
                    ::std::option::Option::Some(route::Route::Irqchip(ref mut v)) => v,
                    _ => panic!(),
                }
            }

            // Take field
            pub fn take_irqchip(&mut self) -> route::Irqchip {
                if self.has_irqchip() {
                    match self.route.take() {
                        ::std::option::Option::Some(route::Route::Irqchip(v)) => v,
                        _ => panic!(),
                    }
                } else {
                    route::Irqchip::new()
                }
            }

            // .MainRequest.SetIrqRouting.Route.Msi msi = 3;

            pub fn msi(&self) -> &route::Msi {
                match self.route {
                    ::std::option::Option::Some(route::Route::Msi(ref v)) => v,
                    _ => <route::Msi as ::protobuf::Message>::default_instance(),
                }
            }

            pub fn clear_msi(&mut self) {
                self.route = ::std::option::Option::None;
            }

            pub fn has_msi(&self) -> bool {
                match self.route {
                    ::std::option::Option::Some(route::Route::Msi(..)) => true,
                    _ => false,
                }
            }

            // Param is passed by value, moved
            pub fn set_msi(&mut self, v: route::Msi) {
                self.route = ::std::option::Option::Some(route::Route::Msi(v))
            }

            // Mutable pointer to the field.
            pub fn mut_msi(&mut self) -> &mut route::Msi {
                if let ::std::option::Option::Some(route::Route::Msi(_)) = self.route {
                } else {
                    self.route = ::std::option::Option::Some(route::Route::Msi(route::Msi::new()));
                }
                match self.route {
                    ::std::option::Option::Some(route::Route::Msi(ref mut v)) => v,
                    _ => panic!(),
                }
            }

            // Take field
            pub fn take_msi(&mut self) -> route::Msi {
                if self.has_msi() {
                    match self.route.take() {
                        ::std::option::Option::Some(route::Route::Msi(v)) => v,
                        _ => panic!(),
                    }
                } else {
                    route::Msi::new()
                }
            }

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(3);
                let mut oneofs = ::std::vec::Vec::with_capacity(1);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "irq_id",
                    |m: &Route| { &m.irq_id },
                    |m: &mut Route| { &mut m.irq_id },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, route::Irqchip>(
                    "irqchip",
                    Route::has_irqchip,
                    Route::irqchip,
                    Route::mut_irqchip,
                    Route::set_irqchip,
                ));
                fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, route::Msi>(
                    "msi",
                    Route::has_msi,
                    Route::msi,
                    Route::mut_msi,
                    Route::set_msi,
                ));
                oneofs.push(route::Route::generated_oneof_descriptor_data());
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Route>(
                    "MainRequest.SetIrqRouting.Route",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for Route {
            const NAME: &'static str = "Route";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.irq_id = is.read_uint32()?;
                        },
                        18 => {
                            self.route = ::std::option::Option::Some(route::Route::Irqchip(is.read_message()?));
                        },
                        26 => {
                            self.route = ::std::option::Option::Some(route::Route::Msi(is.read_message()?));
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.irq_id != 0 {
                    my_size += ::protobuf::rt::uint32_size(1, self.irq_id);
                }
                if let ::std::option::Option::Some(ref v) = self.route {
                    match v {
                        &route::Route::Irqchip(ref v) => {
                            let len = v.compute_size();
                            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                        },
                        &route::Route::Msi(ref v) => {
                            let len = v.compute_size();
                            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                        },
                    };
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.irq_id != 0 {
                    os.write_uint32(1, self.irq_id)?;
                }
                if let ::std::option::Option::Some(ref v) = self.route {
                    match v {
                        &route::Route::Irqchip(ref v) => {
                            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                        },
                        &route::Route::Msi(ref v) => {
                            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                        },
                    };
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.irq_id = 0;
                self.route = ::std::option::Option::None;
                self.route = ::std::option::Option::None;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Route {
                static instance: Route = Route {
                    irq_id: 0,
                    route: ::std::option::Option::None,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for Route {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("MainRequest.SetIrqRouting.Route").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for Route {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        /// Nested message and enums of message `Route`
        pub mod route {

            #[derive(Clone,PartialEq,Debug)]
            #[non_exhaustive]
            // @@protoc_insertion_point(oneof:MainRequest.SetIrqRouting.Route.route)
            pub enum Route {
                // @@protoc_insertion_point(oneof_field:MainRequest.SetIrqRouting.Route.irqchip)
                Irqchip(Irqchip),
                // @@protoc_insertion_point(oneof_field:MainRequest.SetIrqRouting.Route.msi)
                Msi(Msi),
            }

            impl ::protobuf::Oneof for Route {
            }

            impl ::protobuf::OneofFull for Route {
                fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
                    static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
                    descriptor.get(|| <super::Route as ::protobuf::MessageFull>::descriptor().oneof_by_name("route").unwrap()).clone()
                }
            }

            impl Route {
                pub(in super::super::super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
                    ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Route>("route")
                }
            }
            // @@protoc_insertion_point(message:MainRequest.SetIrqRouting.Route.Irqchip)
            #[derive(PartialEq,Clone,Default,Debug)]
            pub struct Irqchip {
                // message fields
                // @@protoc_insertion_point(field:MainRequest.SetIrqRouting.Route.Irqchip.irqchip)
                pub irqchip: u32,
                // @@protoc_insertion_point(field:MainRequest.SetIrqRouting.Route.Irqchip.pin)
                pub pin: u32,
                // special fields
                // @@protoc_insertion_point(special_field:MainRequest.SetIrqRouting.Route.Irqchip.special_fields)
                pub special_fields: ::protobuf::SpecialFields,
            }

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

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

                pub(in super::super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                    let mut fields = ::std::vec::Vec::with_capacity(2);
                    let mut oneofs = ::std::vec::Vec::with_capacity(0);
                    fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                        "irqchip",
                        |m: &Irqchip| { &m.irqchip },
                        |m: &mut Irqchip| { &mut m.irqchip },
                    ));
                    fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                        "pin",
                        |m: &Irqchip| { &m.pin },
                        |m: &mut Irqchip| { &mut m.pin },
                    ));
                    ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Irqchip>(
                        "MainRequest.SetIrqRouting.Route.Irqchip",
                        fields,
                        oneofs,
                    )
                }
            }

            impl ::protobuf::Message for Irqchip {
                const NAME: &'static str = "Irqchip";

                fn is_initialized(&self) -> bool {
                    true
                }

                fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            8 => {
                                self.irqchip = is.read_uint32()?;
                            },
                            16 => {
                                self.pin = is.read_uint32()?;
                            },
                            tag => {
                                ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                            },
                        };
                    }
                    ::std::result::Result::Ok(())
                }

                // Compute sizes of nested messages
                #[allow(unused_variables)]
                fn compute_size(&self) -> u64 {
                    let mut my_size = 0;
                    if self.irqchip != 0 {
                        my_size += ::protobuf::rt::uint32_size(1, self.irqchip);
                    }
                    if self.pin != 0 {
                        my_size += ::protobuf::rt::uint32_size(2, self.pin);
                    }
                    my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                    self.special_fields.cached_size().set(my_size as u32);
                    my_size
                }

                fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                    if self.irqchip != 0 {
                        os.write_uint32(1, self.irqchip)?;
                    }
                    if self.pin != 0 {
                        os.write_uint32(2, self.pin)?;
                    }
                    os.write_unknown_fields(self.special_fields.unknown_fields())?;
                    ::std::result::Result::Ok(())
                }

                fn special_fields(&self) -> &::protobuf::SpecialFields {
                    &self.special_fields
                }

                fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                    &mut self.special_fields
                }

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

                fn clear(&mut self) {
                    self.irqchip = 0;
                    self.pin = 0;
                    self.special_fields.clear();
                }

                fn default_instance() -> &'static Irqchip {
                    static instance: Irqchip = Irqchip {
                        irqchip: 0,
                        pin: 0,
                        special_fields: ::protobuf::SpecialFields::new(),
                    };
                    &instance
                }
            }

            impl ::protobuf::MessageFull for Irqchip {
                fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                    static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                    descriptor.get(|| super::super::super::file_descriptor().message_by_package_relative_name("MainRequest.SetIrqRouting.Route.Irqchip").unwrap()).clone()
                }
            }

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

            impl ::protobuf::reflect::ProtobufValue for Irqchip {
                type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
            }

            // @@protoc_insertion_point(message:MainRequest.SetIrqRouting.Route.Msi)
            #[derive(PartialEq,Clone,Default,Debug)]
            pub struct Msi {
                // message fields
                // @@protoc_insertion_point(field:MainRequest.SetIrqRouting.Route.Msi.address)
                pub address: u64,
                // @@protoc_insertion_point(field:MainRequest.SetIrqRouting.Route.Msi.data)
                pub data: u32,
                // special fields
                // @@protoc_insertion_point(special_field:MainRequest.SetIrqRouting.Route.Msi.special_fields)
                pub special_fields: ::protobuf::SpecialFields,
            }

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

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

                pub(in super::super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                    let mut fields = ::std::vec::Vec::with_capacity(2);
                    let mut oneofs = ::std::vec::Vec::with_capacity(0);
                    fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                        "address",
                        |m: &Msi| { &m.address },
                        |m: &mut Msi| { &mut m.address },
                    ));
                    fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                        "data",
                        |m: &Msi| { &m.data },
                        |m: &mut Msi| { &mut m.data },
                    ));
                    ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Msi>(
                        "MainRequest.SetIrqRouting.Route.Msi",
                        fields,
                        oneofs,
                    )
                }
            }

            impl ::protobuf::Message for Msi {
                const NAME: &'static str = "Msi";

                fn is_initialized(&self) -> bool {
                    true
                }

                fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            8 => {
                                self.address = is.read_uint64()?;
                            },
                            16 => {
                                self.data = is.read_uint32()?;
                            },
                            tag => {
                                ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                            },
                        };
                    }
                    ::std::result::Result::Ok(())
                }

                // Compute sizes of nested messages
                #[allow(unused_variables)]
                fn compute_size(&self) -> u64 {
                    let mut my_size = 0;
                    if self.address != 0 {
                        my_size += ::protobuf::rt::uint64_size(1, self.address);
                    }
                    if self.data != 0 {
                        my_size += ::protobuf::rt::uint32_size(2, self.data);
                    }
                    my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                    self.special_fields.cached_size().set(my_size as u32);
                    my_size
                }

                fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                    if self.address != 0 {
                        os.write_uint64(1, self.address)?;
                    }
                    if self.data != 0 {
                        os.write_uint32(2, self.data)?;
                    }
                    os.write_unknown_fields(self.special_fields.unknown_fields())?;
                    ::std::result::Result::Ok(())
                }

                fn special_fields(&self) -> &::protobuf::SpecialFields {
                    &self.special_fields
                }

                fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                    &mut self.special_fields
                }

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

                fn clear(&mut self) {
                    self.address = 0;
                    self.data = 0;
                    self.special_fields.clear();
                }

                fn default_instance() -> &'static Msi {
                    static instance: Msi = Msi {
                        address: 0,
                        data: 0,
                        special_fields: ::protobuf::SpecialFields::new(),
                    };
                    &instance
                }
            }

            impl ::protobuf::MessageFull for Msi {
                fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                    static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                    descriptor.get(|| super::super::super::file_descriptor().message_by_package_relative_name("MainRequest.SetIrqRouting.Route.Msi").unwrap()).clone()
                }
            }

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

            impl ::protobuf::reflect::ProtobufValue for Msi {
                type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
            }
        }
    }

    // @@protoc_insertion_point(message:MainRequest.GetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetState {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.GetState.set)
        pub set: ::protobuf::EnumOrUnknown<StateSet>,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.GetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "set",
                |m: &GetState| { &m.set },
                |m: &mut GetState| { &mut m.set },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetState>(
                "MainRequest.GetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetState {
        const NAME: &'static str = "GetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.set = is.read_enum_or_unknown()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::PIC0) {
                my_size += ::protobuf::rt::int32_size(1, self.set.value());
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::PIC0) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.set))?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.set = ::protobuf::EnumOrUnknown::new(StateSet::PIC0);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetState {
            static instance: GetState = GetState {
                set: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.GetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.SetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetState {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.SetState.set)
        pub set: ::protobuf::EnumOrUnknown<StateSet>,
        // @@protoc_insertion_point(field:MainRequest.SetState.state)
        pub state: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.SetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(2);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "set",
                |m: &SetState| { &m.set },
                |m: &mut SetState| { &mut m.set },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "state",
                |m: &SetState| { &m.state },
                |m: &mut SetState| { &mut m.state },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetState>(
                "MainRequest.SetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetState {
        const NAME: &'static str = "SetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.set = is.read_enum_or_unknown()?;
                    },
                    18 => {
                        self.state = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::PIC0) {
                my_size += ::protobuf::rt::int32_size(1, self.set.value());
            }
            if !self.state.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.state);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::PIC0) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.set))?;
            }
            if !self.state.is_empty() {
                os.write_bytes(2, &self.state)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.set = ::protobuf::EnumOrUnknown::new(StateSet::PIC0);
            self.state.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetState {
            static instance: SetState = SetState {
                set: ::protobuf::EnumOrUnknown::from_i32(0),
                state: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.SetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.SetIdentityMapAddr)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetIdentityMapAddr {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.SetIdentityMapAddr.address)
        pub address: u32,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.SetIdentityMapAddr.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "address",
                |m: &SetIdentityMapAddr| { &m.address },
                |m: &mut SetIdentityMapAddr| { &mut m.address },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetIdentityMapAddr>(
                "MainRequest.SetIdentityMapAddr",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetIdentityMapAddr {
        const NAME: &'static str = "SetIdentityMapAddr";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.address = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.address != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.address);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.address != 0 {
                os.write_uint32(1, self.address)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.address = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetIdentityMapAddr {
            static instance: SetIdentityMapAddr = SetIdentityMapAddr {
                address: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetIdentityMapAddr {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.SetIdentityMapAddr").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetIdentityMapAddr {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.PauseVcpus)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PauseVcpus {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.PauseVcpus.cpu_mask)
        pub cpu_mask: u64,
        // @@protoc_insertion_point(field:MainRequest.PauseVcpus.user)
        pub user: u64,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.PauseVcpus.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(2);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "cpu_mask",
                |m: &PauseVcpus| { &m.cpu_mask },
                |m: &mut PauseVcpus| { &mut m.cpu_mask },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "user",
                |m: &PauseVcpus| { &m.user },
                |m: &mut PauseVcpus| { &mut m.user },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PauseVcpus>(
                "MainRequest.PauseVcpus",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for PauseVcpus {
        const NAME: &'static str = "PauseVcpus";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.cpu_mask = is.read_uint64()?;
                    },
                    16 => {
                        self.user = is.read_uint64()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.cpu_mask != 0 {
                my_size += ::protobuf::rt::uint64_size(1, self.cpu_mask);
            }
            if self.user != 0 {
                my_size += ::protobuf::rt::uint64_size(2, self.user);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.cpu_mask != 0 {
                os.write_uint64(1, self.cpu_mask)?;
            }
            if self.user != 0 {
                os.write_uint64(2, self.user)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.cpu_mask = 0;
            self.user = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PauseVcpus {
            static instance: PauseVcpus = PauseVcpus {
                cpu_mask: 0,
                user: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for PauseVcpus {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.PauseVcpus").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for PauseVcpus {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.GetVcpus)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetVcpus {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.GetVcpus.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetVcpus>(
                "MainRequest.GetVcpus",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetVcpus {
        const NAME: &'static str = "GetVcpus";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetVcpus {
            static instance: GetVcpus = GetVcpus {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetVcpus {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.GetVcpus").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetVcpus {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.Start)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Start {
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.Start.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Start>(
                "MainRequest.Start",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Start {
        const NAME: &'static str = "Start";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Start {
            static instance: Start = Start {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Start {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.Start").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Start {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainRequest.SetCallHint)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetCallHint {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.SetCallHint.space)
        pub space: ::protobuf::EnumOrUnknown<super::AddressSpace>,
        // @@protoc_insertion_point(field:MainRequest.SetCallHint.address)
        pub address: u64,
        // @@protoc_insertion_point(field:MainRequest.SetCallHint.on_write)
        pub on_write: bool,
        // @@protoc_insertion_point(field:MainRequest.SetCallHint.hints)
        pub hints: ::std::vec::Vec<set_call_hint::RegHint>,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.SetCallHint.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(4);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "space",
                |m: &SetCallHint| { &m.space },
                |m: &mut SetCallHint| { &mut m.space },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "address",
                |m: &SetCallHint| { &m.address },
                |m: &mut SetCallHint| { &mut m.address },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "on_write",
                |m: &SetCallHint| { &m.on_write },
                |m: &mut SetCallHint| { &mut m.on_write },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "hints",
                |m: &SetCallHint| { &m.hints },
                |m: &mut SetCallHint| { &mut m.hints },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetCallHint>(
                "MainRequest.SetCallHint",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetCallHint {
        const NAME: &'static str = "SetCallHint";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.space = is.read_enum_or_unknown()?;
                    },
                    16 => {
                        self.address = is.read_uint64()?;
                    },
                    24 => {
                        self.on_write = is.read_bool()?;
                    },
                    34 => {
                        self.hints.push(is.read_message()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.space != ::protobuf::EnumOrUnknown::new(super::AddressSpace::IOPORT) {
                my_size += ::protobuf::rt::int32_size(1, self.space.value());
            }
            if self.address != 0 {
                my_size += ::protobuf::rt::uint64_size(2, self.address);
            }
            if self.on_write != false {
                my_size += 1 + 1;
            }
            for value in &self.hints {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.space != ::protobuf::EnumOrUnknown::new(super::AddressSpace::IOPORT) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.space))?;
            }
            if self.address != 0 {
                os.write_uint64(2, self.address)?;
            }
            if self.on_write != false {
                os.write_bool(3, self.on_write)?;
            }
            for v in &self.hints {
                ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.space = ::protobuf::EnumOrUnknown::new(super::AddressSpace::IOPORT);
            self.address = 0;
            self.on_write = false;
            self.hints.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetCallHint {
            static instance: SetCallHint = SetCallHint {
                space: ::protobuf::EnumOrUnknown::from_i32(0),
                address: 0,
                on_write: false,
                hints: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetCallHint {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.SetCallHint").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetCallHint {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    /// Nested message and enums of message `SetCallHint`
    pub mod set_call_hint {
        // @@protoc_insertion_point(message:MainRequest.SetCallHint.RegHint)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct RegHint {
            // message fields
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.match_rax)
            pub match_rax: bool,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.match_rbx)
            pub match_rbx: bool,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.match_rcx)
            pub match_rcx: bool,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.match_rdx)
            pub match_rdx: bool,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.rax)
            pub rax: u64,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.rbx)
            pub rbx: u64,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.rcx)
            pub rcx: u64,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.rdx)
            pub rdx: u64,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.send_sregs)
            pub send_sregs: bool,
            // @@protoc_insertion_point(field:MainRequest.SetCallHint.RegHint.send_debugregs)
            pub send_debugregs: bool,
            // special fields
            // @@protoc_insertion_point(special_field:MainRequest.SetCallHint.RegHint.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(10);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "match_rax",
                    |m: &RegHint| { &m.match_rax },
                    |m: &mut RegHint| { &mut m.match_rax },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "match_rbx",
                    |m: &RegHint| { &m.match_rbx },
                    |m: &mut RegHint| { &mut m.match_rbx },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "match_rcx",
                    |m: &RegHint| { &m.match_rcx },
                    |m: &mut RegHint| { &mut m.match_rcx },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "match_rdx",
                    |m: &RegHint| { &m.match_rdx },
                    |m: &mut RegHint| { &mut m.match_rdx },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "rax",
                    |m: &RegHint| { &m.rax },
                    |m: &mut RegHint| { &mut m.rax },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "rbx",
                    |m: &RegHint| { &m.rbx },
                    |m: &mut RegHint| { &mut m.rbx },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "rcx",
                    |m: &RegHint| { &m.rcx },
                    |m: &mut RegHint| { &mut m.rcx },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "rdx",
                    |m: &RegHint| { &m.rdx },
                    |m: &mut RegHint| { &mut m.rdx },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "send_sregs",
                    |m: &RegHint| { &m.send_sregs },
                    |m: &mut RegHint| { &mut m.send_sregs },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "send_debugregs",
                    |m: &RegHint| { &m.send_debugregs },
                    |m: &mut RegHint| { &mut m.send_debugregs },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegHint>(
                    "MainRequest.SetCallHint.RegHint",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for RegHint {
            const NAME: &'static str = "RegHint";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.match_rax = is.read_bool()?;
                        },
                        16 => {
                            self.match_rbx = is.read_bool()?;
                        },
                        24 => {
                            self.match_rcx = is.read_bool()?;
                        },
                        32 => {
                            self.match_rdx = is.read_bool()?;
                        },
                        40 => {
                            self.rax = is.read_uint64()?;
                        },
                        48 => {
                            self.rbx = is.read_uint64()?;
                        },
                        56 => {
                            self.rcx = is.read_uint64()?;
                        },
                        64 => {
                            self.rdx = is.read_uint64()?;
                        },
                        72 => {
                            self.send_sregs = is.read_bool()?;
                        },
                        80 => {
                            self.send_debugregs = is.read_bool()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.match_rax != false {
                    my_size += 1 + 1;
                }
                if self.match_rbx != false {
                    my_size += 1 + 1;
                }
                if self.match_rcx != false {
                    my_size += 1 + 1;
                }
                if self.match_rdx != false {
                    my_size += 1 + 1;
                }
                if self.rax != 0 {
                    my_size += ::protobuf::rt::uint64_size(5, self.rax);
                }
                if self.rbx != 0 {
                    my_size += ::protobuf::rt::uint64_size(6, self.rbx);
                }
                if self.rcx != 0 {
                    my_size += ::protobuf::rt::uint64_size(7, self.rcx);
                }
                if self.rdx != 0 {
                    my_size += ::protobuf::rt::uint64_size(8, self.rdx);
                }
                if self.send_sregs != false {
                    my_size += 1 + 1;
                }
                if self.send_debugregs != false {
                    my_size += 1 + 1;
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.match_rax != false {
                    os.write_bool(1, self.match_rax)?;
                }
                if self.match_rbx != false {
                    os.write_bool(2, self.match_rbx)?;
                }
                if self.match_rcx != false {
                    os.write_bool(3, self.match_rcx)?;
                }
                if self.match_rdx != false {
                    os.write_bool(4, self.match_rdx)?;
                }
                if self.rax != 0 {
                    os.write_uint64(5, self.rax)?;
                }
                if self.rbx != 0 {
                    os.write_uint64(6, self.rbx)?;
                }
                if self.rcx != 0 {
                    os.write_uint64(7, self.rcx)?;
                }
                if self.rdx != 0 {
                    os.write_uint64(8, self.rdx)?;
                }
                if self.send_sregs != false {
                    os.write_bool(9, self.send_sregs)?;
                }
                if self.send_debugregs != false {
                    os.write_bool(10, self.send_debugregs)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.match_rax = false;
                self.match_rbx = false;
                self.match_rcx = false;
                self.match_rdx = false;
                self.rax = 0;
                self.rbx = 0;
                self.rcx = 0;
                self.rdx = 0;
                self.send_sregs = false;
                self.send_debugregs = false;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static RegHint {
                static instance: RegHint = RegHint {
                    match_rax: false,
                    match_rbx: false,
                    match_rcx: false,
                    match_rdx: false,
                    rax: 0,
                    rbx: 0,
                    rcx: 0,
                    rdx: 0,
                    send_sregs: false,
                    send_debugregs: false,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for RegHint {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("MainRequest.SetCallHint.RegHint").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for RegHint {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }
    }

    // @@protoc_insertion_point(message:MainRequest.MemoryDirtyLog)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MemoryDirtyLog {
        // message fields
        // @@protoc_insertion_point(field:MainRequest.MemoryDirtyLog.id)
        pub id: u32,
        // special fields
        // @@protoc_insertion_point(special_field:MainRequest.MemoryDirtyLog.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "id",
                |m: &MemoryDirtyLog| { &m.id },
                |m: &mut MemoryDirtyLog| { &mut m.id },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MemoryDirtyLog>(
                "MainRequest.MemoryDirtyLog",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for MemoryDirtyLog {
        const NAME: &'static str = "MemoryDirtyLog";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.id = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.id != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.id);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.id != 0 {
                os.write_uint32(1, self.id)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.id = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static MemoryDirtyLog {
            static instance: MemoryDirtyLog = MemoryDirtyLog {
                id: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for MemoryDirtyLog {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainRequest.MemoryDirtyLog").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for MemoryDirtyLog {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:MainRequest.StateSet)
    pub enum StateSet {
        // @@protoc_insertion_point(enum_value:MainRequest.StateSet.PIC0)
        PIC0 = 0,
        // @@protoc_insertion_point(enum_value:MainRequest.StateSet.PIC1)
        PIC1 = 1,
        // @@protoc_insertion_point(enum_value:MainRequest.StateSet.IOAPIC)
        IOAPIC = 2,
        // @@protoc_insertion_point(enum_value:MainRequest.StateSet.PIT)
        PIT = 3,
        // @@protoc_insertion_point(enum_value:MainRequest.StateSet.CLOCK)
        CLOCK = 4,
    }

    impl ::protobuf::Enum for StateSet {
        const NAME: &'static str = "StateSet";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<StateSet> {
            match value {
                0 => ::std::option::Option::Some(StateSet::PIC0),
                1 => ::std::option::Option::Some(StateSet::PIC1),
                2 => ::std::option::Option::Some(StateSet::IOAPIC),
                3 => ::std::option::Option::Some(StateSet::PIT),
                4 => ::std::option::Option::Some(StateSet::CLOCK),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<StateSet> {
            match str {
                "PIC0" => ::std::option::Option::Some(StateSet::PIC0),
                "PIC1" => ::std::option::Option::Some(StateSet::PIC1),
                "IOAPIC" => ::std::option::Option::Some(StateSet::IOAPIC),
                "PIT" => ::std::option::Option::Some(StateSet::PIT),
                "CLOCK" => ::std::option::Option::Some(StateSet::CLOCK),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [StateSet] = &[
            StateSet::PIC0,
            StateSet::PIC1,
            StateSet::IOAPIC,
            StateSet::PIT,
            StateSet::CLOCK,
        ];
    }

    impl ::protobuf::EnumFull for StateSet {
        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("MainRequest.StateSet").unwrap()).clone()
        }

        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
            let index = *self as usize;
            Self::enum_descriptor().value_by_index(index)
        }
    }

    impl ::std::default::Default for StateSet {
        fn default() -> Self {
            StateSet::PIC0
        }
    }

    impl StateSet {
        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<StateSet>("MainRequest.StateSet")
        }
    }
}

// @@protoc_insertion_point(message:MainResponse)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct MainResponse {
    // message fields
    // @@protoc_insertion_point(field:MainResponse.errno)
    pub errno: i32,
    // message oneof groups
    pub message: ::std::option::Option<main_response::Message>,
    // special fields
    // @@protoc_insertion_point(special_field:MainResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .MainResponse.Create create = 2;

    pub fn create(&self) -> &main_response::Create {
        match self.message {
            ::std::option::Option::Some(main_response::Message::Create(ref v)) => v,
            _ => <main_response::Create as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_create(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_create(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::Create(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_create(&mut self, v: main_response::Create) {
        self.message = ::std::option::Option::Some(main_response::Message::Create(v))
    }

    // Mutable pointer to the field.
    pub fn mut_create(&mut self) -> &mut main_response::Create {
        if let ::std::option::Option::Some(main_response::Message::Create(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::Create(main_response::Create::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::Create(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_create(&mut self) -> main_response::Create {
        if self.has_create() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::Create(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::Create::new()
        }
    }

    // .MainResponse.Destroy destroy = 3;

    pub fn destroy(&self) -> &main_response::Destroy {
        match self.message {
            ::std::option::Option::Some(main_response::Message::Destroy(ref v)) => v,
            _ => <main_response::Destroy as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_destroy(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_destroy(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::Destroy(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_destroy(&mut self, v: main_response::Destroy) {
        self.message = ::std::option::Option::Some(main_response::Message::Destroy(v))
    }

    // Mutable pointer to the field.
    pub fn mut_destroy(&mut self) -> &mut main_response::Destroy {
        if let ::std::option::Option::Some(main_response::Message::Destroy(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::Destroy(main_response::Destroy::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::Destroy(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_destroy(&mut self) -> main_response::Destroy {
        if self.has_destroy() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::Destroy(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::Destroy::new()
        }
    }

    // .MainResponse.NewConnection new_connection = 4;

    pub fn new_connection(&self) -> &main_response::NewConnection {
        match self.message {
            ::std::option::Option::Some(main_response::Message::NewConnection(ref v)) => v,
            _ => <main_response::NewConnection as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_new_connection(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_new_connection(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::NewConnection(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_new_connection(&mut self, v: main_response::NewConnection) {
        self.message = ::std::option::Option::Some(main_response::Message::NewConnection(v))
    }

    // Mutable pointer to the field.
    pub fn mut_new_connection(&mut self) -> &mut main_response::NewConnection {
        if let ::std::option::Option::Some(main_response::Message::NewConnection(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::NewConnection(main_response::NewConnection::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::NewConnection(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_new_connection(&mut self) -> main_response::NewConnection {
        if self.has_new_connection() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::NewConnection(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::NewConnection::new()
        }
    }

    // .MainResponse.GetShutdownEventfd get_shutdown_eventfd = 5;

    pub fn get_shutdown_eventfd(&self) -> &main_response::GetShutdownEventfd {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(ref v)) => v,
            _ => <main_response::GetShutdownEventfd as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_shutdown_eventfd(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_shutdown_eventfd(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_shutdown_eventfd(&mut self, v: main_response::GetShutdownEventfd) {
        self.message = ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_shutdown_eventfd(&mut self) -> &mut main_response::GetShutdownEventfd {
        if let ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(main_response::GetShutdownEventfd::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_shutdown_eventfd(&mut self) -> main_response::GetShutdownEventfd {
        if self.has_get_shutdown_eventfd() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::GetShutdownEventfd::new()
        }
    }

    // .MainResponse.CheckExtension check_extension = 6;

    pub fn check_extension(&self) -> &main_response::CheckExtension {
        match self.message {
            ::std::option::Option::Some(main_response::Message::CheckExtension(ref v)) => v,
            _ => <main_response::CheckExtension as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_check_extension(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_check_extension(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::CheckExtension(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_check_extension(&mut self, v: main_response::CheckExtension) {
        self.message = ::std::option::Option::Some(main_response::Message::CheckExtension(v))
    }

    // Mutable pointer to the field.
    pub fn mut_check_extension(&mut self) -> &mut main_response::CheckExtension {
        if let ::std::option::Option::Some(main_response::Message::CheckExtension(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::CheckExtension(main_response::CheckExtension::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::CheckExtension(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_check_extension(&mut self) -> main_response::CheckExtension {
        if self.has_check_extension() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::CheckExtension(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::CheckExtension::new()
        }
    }

    // .MainResponse.CpuidResponse get_supported_cpuid = 7;

    pub fn get_supported_cpuid(&self) -> &main_response::CpuidResponse {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(ref v)) => v,
            _ => <main_response::CpuidResponse as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_supported_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_supported_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_supported_cpuid(&mut self, v: main_response::CpuidResponse) {
        self.message = ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_supported_cpuid(&mut self) -> &mut main_response::CpuidResponse {
        if let ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(main_response::CpuidResponse::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_supported_cpuid(&mut self) -> main_response::CpuidResponse {
        if self.has_get_supported_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::CpuidResponse::new()
        }
    }

    // .MainResponse.CpuidResponse get_emulated_cpuid = 8;

    pub fn get_emulated_cpuid(&self) -> &main_response::CpuidResponse {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(ref v)) => v,
            _ => <main_response::CpuidResponse as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_emulated_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_emulated_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_emulated_cpuid(&mut self, v: main_response::CpuidResponse) {
        self.message = ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_emulated_cpuid(&mut self) -> &mut main_response::CpuidResponse {
        if let ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(main_response::CpuidResponse::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_emulated_cpuid(&mut self) -> main_response::CpuidResponse {
        if self.has_get_emulated_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::CpuidResponse::new()
        }
    }

    // .MainResponse.MsrListResponse get_msr_index_list = 9;

    pub fn get_msr_index_list(&self) -> &main_response::MsrListResponse {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetMsrIndexList(ref v)) => v,
            _ => <main_response::MsrListResponse as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_msr_index_list(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_msr_index_list(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetMsrIndexList(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_msr_index_list(&mut self, v: main_response::MsrListResponse) {
        self.message = ::std::option::Option::Some(main_response::Message::GetMsrIndexList(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_msr_index_list(&mut self) -> &mut main_response::MsrListResponse {
        if let ::std::option::Option::Some(main_response::Message::GetMsrIndexList(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetMsrIndexList(main_response::MsrListResponse::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetMsrIndexList(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_msr_index_list(&mut self) -> main_response::MsrListResponse {
        if self.has_get_msr_index_list() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetMsrIndexList(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::MsrListResponse::new()
        }
    }

    // .MainResponse.GetNetConfig get_net_config = 10;

    pub fn get_net_config(&self) -> &main_response::GetNetConfig {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetNetConfig(ref v)) => v,
            _ => <main_response::GetNetConfig as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_net_config(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_net_config(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetNetConfig(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_net_config(&mut self, v: main_response::GetNetConfig) {
        self.message = ::std::option::Option::Some(main_response::Message::GetNetConfig(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_net_config(&mut self) -> &mut main_response::GetNetConfig {
        if let ::std::option::Option::Some(main_response::Message::GetNetConfig(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetNetConfig(main_response::GetNetConfig::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetNetConfig(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_net_config(&mut self) -> main_response::GetNetConfig {
        if self.has_get_net_config() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetNetConfig(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::GetNetConfig::new()
        }
    }

    // .MainResponse.ReserveRange reserve_range = 11;

    pub fn reserve_range(&self) -> &main_response::ReserveRange {
        match self.message {
            ::std::option::Option::Some(main_response::Message::ReserveRange(ref v)) => v,
            _ => <main_response::ReserveRange as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_reserve_range(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_reserve_range(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::ReserveRange(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_reserve_range(&mut self, v: main_response::ReserveRange) {
        self.message = ::std::option::Option::Some(main_response::Message::ReserveRange(v))
    }

    // Mutable pointer to the field.
    pub fn mut_reserve_range(&mut self) -> &mut main_response::ReserveRange {
        if let ::std::option::Option::Some(main_response::Message::ReserveRange(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::ReserveRange(main_response::ReserveRange::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::ReserveRange(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_reserve_range(&mut self) -> main_response::ReserveRange {
        if self.has_reserve_range() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::ReserveRange(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::ReserveRange::new()
        }
    }

    // .MainResponse.SetIrq set_irq = 12;

    pub fn set_irq(&self) -> &main_response::SetIrq {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIrq(ref v)) => v,
            _ => <main_response::SetIrq as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_irq(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_irq(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIrq(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_irq(&mut self, v: main_response::SetIrq) {
        self.message = ::std::option::Option::Some(main_response::Message::SetIrq(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_irq(&mut self) -> &mut main_response::SetIrq {
        if let ::std::option::Option::Some(main_response::Message::SetIrq(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::SetIrq(main_response::SetIrq::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIrq(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_irq(&mut self) -> main_response::SetIrq {
        if self.has_set_irq() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::SetIrq(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::SetIrq::new()
        }
    }

    // .MainResponse.SetIrqRouting set_irq_routing = 13;

    pub fn set_irq_routing(&self) -> &main_response::SetIrqRouting {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIrqRouting(ref v)) => v,
            _ => <main_response::SetIrqRouting as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_irq_routing(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_irq_routing(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIrqRouting(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_irq_routing(&mut self, v: main_response::SetIrqRouting) {
        self.message = ::std::option::Option::Some(main_response::Message::SetIrqRouting(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_irq_routing(&mut self) -> &mut main_response::SetIrqRouting {
        if let ::std::option::Option::Some(main_response::Message::SetIrqRouting(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::SetIrqRouting(main_response::SetIrqRouting::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIrqRouting(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_irq_routing(&mut self) -> main_response::SetIrqRouting {
        if self.has_set_irq_routing() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::SetIrqRouting(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::SetIrqRouting::new()
        }
    }

    // .MainResponse.GetState get_state = 14;

    pub fn get_state(&self) -> &main_response::GetState {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetState(ref v)) => v,
            _ => <main_response::GetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_state(&mut self, v: main_response::GetState) {
        self.message = ::std::option::Option::Some(main_response::Message::GetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_state(&mut self) -> &mut main_response::GetState {
        if let ::std::option::Option::Some(main_response::Message::GetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetState(main_response::GetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_state(&mut self) -> main_response::GetState {
        if self.has_get_state() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetState(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::GetState::new()
        }
    }

    // .MainResponse.SetState set_state = 15;

    pub fn set_state(&self) -> &main_response::SetState {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetState(ref v)) => v,
            _ => <main_response::SetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_state(&mut self, v: main_response::SetState) {
        self.message = ::std::option::Option::Some(main_response::Message::SetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_state(&mut self) -> &mut main_response::SetState {
        if let ::std::option::Option::Some(main_response::Message::SetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::SetState(main_response::SetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_state(&mut self) -> main_response::SetState {
        if self.has_set_state() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::SetState(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::SetState::new()
        }
    }

    // .MainResponse.SetIdentityMapAddr set_identity_map_addr = 16;

    pub fn set_identity_map_addr(&self) -> &main_response::SetIdentityMapAddr {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(ref v)) => v,
            _ => <main_response::SetIdentityMapAddr as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_identity_map_addr(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_identity_map_addr(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_identity_map_addr(&mut self, v: main_response::SetIdentityMapAddr) {
        self.message = ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_identity_map_addr(&mut self) -> &mut main_response::SetIdentityMapAddr {
        if let ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(main_response::SetIdentityMapAddr::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_identity_map_addr(&mut self) -> main_response::SetIdentityMapAddr {
        if self.has_set_identity_map_addr() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::SetIdentityMapAddr::new()
        }
    }

    // .MainResponse.PauseVcpus pause_vcpus = 17;

    pub fn pause_vcpus(&self) -> &main_response::PauseVcpus {
        match self.message {
            ::std::option::Option::Some(main_response::Message::PauseVcpus(ref v)) => v,
            _ => <main_response::PauseVcpus as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_pause_vcpus(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_pause_vcpus(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::PauseVcpus(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_pause_vcpus(&mut self, v: main_response::PauseVcpus) {
        self.message = ::std::option::Option::Some(main_response::Message::PauseVcpus(v))
    }

    // Mutable pointer to the field.
    pub fn mut_pause_vcpus(&mut self) -> &mut main_response::PauseVcpus {
        if let ::std::option::Option::Some(main_response::Message::PauseVcpus(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::PauseVcpus(main_response::PauseVcpus::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::PauseVcpus(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_pause_vcpus(&mut self) -> main_response::PauseVcpus {
        if self.has_pause_vcpus() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::PauseVcpus(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::PauseVcpus::new()
        }
    }

    // .MainResponse.GetVcpus get_vcpus = 18;

    pub fn get_vcpus(&self) -> &main_response::GetVcpus {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetVcpus(ref v)) => v,
            _ => <main_response::GetVcpus as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_vcpus(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_vcpus(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetVcpus(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_vcpus(&mut self, v: main_response::GetVcpus) {
        self.message = ::std::option::Option::Some(main_response::Message::GetVcpus(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_vcpus(&mut self) -> &mut main_response::GetVcpus {
        if let ::std::option::Option::Some(main_response::Message::GetVcpus(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::GetVcpus(main_response::GetVcpus::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::GetVcpus(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_vcpus(&mut self) -> main_response::GetVcpus {
        if self.has_get_vcpus() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::GetVcpus(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::GetVcpus::new()
        }
    }

    // .MainResponse.Start start = 19;

    pub fn start(&self) -> &main_response::Start {
        match self.message {
            ::std::option::Option::Some(main_response::Message::Start(ref v)) => v,
            _ => <main_response::Start as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_start(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_start(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::Start(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_start(&mut self, v: main_response::Start) {
        self.message = ::std::option::Option::Some(main_response::Message::Start(v))
    }

    // Mutable pointer to the field.
    pub fn mut_start(&mut self) -> &mut main_response::Start {
        if let ::std::option::Option::Some(main_response::Message::Start(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::Start(main_response::Start::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::Start(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_start(&mut self) -> main_response::Start {
        if self.has_start() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::Start(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::Start::new()
        }
    }

    // .MainResponse.SetCallHint set_call_hint = 20;

    pub fn set_call_hint(&self) -> &main_response::SetCallHint {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetCallHint(ref v)) => v,
            _ => <main_response::SetCallHint as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_call_hint(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_call_hint(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetCallHint(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_call_hint(&mut self, v: main_response::SetCallHint) {
        self.message = ::std::option::Option::Some(main_response::Message::SetCallHint(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_call_hint(&mut self) -> &mut main_response::SetCallHint {
        if let ::std::option::Option::Some(main_response::Message::SetCallHint(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::SetCallHint(main_response::SetCallHint::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::SetCallHint(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_call_hint(&mut self) -> main_response::SetCallHint {
        if self.has_set_call_hint() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::SetCallHint(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::SetCallHint::new()
        }
    }

    // .MainResponse.MemoryDirtyLog dirty_log = 101;

    pub fn dirty_log(&self) -> &main_response::MemoryDirtyLog {
        match self.message {
            ::std::option::Option::Some(main_response::Message::DirtyLog(ref v)) => v,
            _ => <main_response::MemoryDirtyLog as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_dirty_log(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_dirty_log(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(main_response::Message::DirtyLog(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_dirty_log(&mut self, v: main_response::MemoryDirtyLog) {
        self.message = ::std::option::Option::Some(main_response::Message::DirtyLog(v))
    }

    // Mutable pointer to the field.
    pub fn mut_dirty_log(&mut self) -> &mut main_response::MemoryDirtyLog {
        if let ::std::option::Option::Some(main_response::Message::DirtyLog(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(main_response::Message::DirtyLog(main_response::MemoryDirtyLog::new()));
        }
        match self.message {
            ::std::option::Option::Some(main_response::Message::DirtyLog(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_dirty_log(&mut self) -> main_response::MemoryDirtyLog {
        if self.has_dirty_log() {
            match self.message.take() {
                ::std::option::Option::Some(main_response::Message::DirtyLog(v)) => v,
                _ => panic!(),
            }
        } else {
            main_response::MemoryDirtyLog::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(21);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "errno",
            |m: &MainResponse| { &m.errno },
            |m: &mut MainResponse| { &mut m.errno },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::Create>(
            "create",
            MainResponse::has_create,
            MainResponse::create,
            MainResponse::mut_create,
            MainResponse::set_create,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::Destroy>(
            "destroy",
            MainResponse::has_destroy,
            MainResponse::destroy,
            MainResponse::mut_destroy,
            MainResponse::set_destroy,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::NewConnection>(
            "new_connection",
            MainResponse::has_new_connection,
            MainResponse::new_connection,
            MainResponse::mut_new_connection,
            MainResponse::set_new_connection,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::GetShutdownEventfd>(
            "get_shutdown_eventfd",
            MainResponse::has_get_shutdown_eventfd,
            MainResponse::get_shutdown_eventfd,
            MainResponse::mut_get_shutdown_eventfd,
            MainResponse::set_get_shutdown_eventfd,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::CheckExtension>(
            "check_extension",
            MainResponse::has_check_extension,
            MainResponse::check_extension,
            MainResponse::mut_check_extension,
            MainResponse::set_check_extension,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::CpuidResponse>(
            "get_supported_cpuid",
            MainResponse::has_get_supported_cpuid,
            MainResponse::get_supported_cpuid,
            MainResponse::mut_get_supported_cpuid,
            MainResponse::set_get_supported_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::CpuidResponse>(
            "get_emulated_cpuid",
            MainResponse::has_get_emulated_cpuid,
            MainResponse::get_emulated_cpuid,
            MainResponse::mut_get_emulated_cpuid,
            MainResponse::set_get_emulated_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::MsrListResponse>(
            "get_msr_index_list",
            MainResponse::has_get_msr_index_list,
            MainResponse::get_msr_index_list,
            MainResponse::mut_get_msr_index_list,
            MainResponse::set_get_msr_index_list,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::GetNetConfig>(
            "get_net_config",
            MainResponse::has_get_net_config,
            MainResponse::get_net_config,
            MainResponse::mut_get_net_config,
            MainResponse::set_get_net_config,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::ReserveRange>(
            "reserve_range",
            MainResponse::has_reserve_range,
            MainResponse::reserve_range,
            MainResponse::mut_reserve_range,
            MainResponse::set_reserve_range,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::SetIrq>(
            "set_irq",
            MainResponse::has_set_irq,
            MainResponse::set_irq,
            MainResponse::mut_set_irq,
            MainResponse::set_set_irq,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::SetIrqRouting>(
            "set_irq_routing",
            MainResponse::has_set_irq_routing,
            MainResponse::set_irq_routing,
            MainResponse::mut_set_irq_routing,
            MainResponse::set_set_irq_routing,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::GetState>(
            "get_state",
            MainResponse::has_get_state,
            MainResponse::get_state,
            MainResponse::mut_get_state,
            MainResponse::set_get_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::SetState>(
            "set_state",
            MainResponse::has_set_state,
            MainResponse::set_state,
            MainResponse::mut_set_state,
            MainResponse::set_set_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::SetIdentityMapAddr>(
            "set_identity_map_addr",
            MainResponse::has_set_identity_map_addr,
            MainResponse::set_identity_map_addr,
            MainResponse::mut_set_identity_map_addr,
            MainResponse::set_set_identity_map_addr,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::PauseVcpus>(
            "pause_vcpus",
            MainResponse::has_pause_vcpus,
            MainResponse::pause_vcpus,
            MainResponse::mut_pause_vcpus,
            MainResponse::set_pause_vcpus,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::GetVcpus>(
            "get_vcpus",
            MainResponse::has_get_vcpus,
            MainResponse::get_vcpus,
            MainResponse::mut_get_vcpus,
            MainResponse::set_get_vcpus,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::Start>(
            "start",
            MainResponse::has_start,
            MainResponse::start,
            MainResponse::mut_start,
            MainResponse::set_start,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::SetCallHint>(
            "set_call_hint",
            MainResponse::has_set_call_hint,
            MainResponse::set_call_hint,
            MainResponse::mut_set_call_hint,
            MainResponse::set_set_call_hint,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, main_response::MemoryDirtyLog>(
            "dirty_log",
            MainResponse::has_dirty_log,
            MainResponse::dirty_log,
            MainResponse::mut_dirty_log,
            MainResponse::set_dirty_log,
        ));
        oneofs.push(main_response::Message::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MainResponse>(
            "MainResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for MainResponse {
    const NAME: &'static str = "MainResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.errno = is.read_sint32()?;
                },
                18 => {
                    self.message = ::std::option::Option::Some(main_response::Message::Create(is.read_message()?));
                },
                26 => {
                    self.message = ::std::option::Option::Some(main_response::Message::Destroy(is.read_message()?));
                },
                34 => {
                    self.message = ::std::option::Option::Some(main_response::Message::NewConnection(is.read_message()?));
                },
                42 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetShutdownEventfd(is.read_message()?));
                },
                50 => {
                    self.message = ::std::option::Option::Some(main_response::Message::CheckExtension(is.read_message()?));
                },
                58 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetSupportedCpuid(is.read_message()?));
                },
                66 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetEmulatedCpuid(is.read_message()?));
                },
                74 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetMsrIndexList(is.read_message()?));
                },
                82 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetNetConfig(is.read_message()?));
                },
                90 => {
                    self.message = ::std::option::Option::Some(main_response::Message::ReserveRange(is.read_message()?));
                },
                98 => {
                    self.message = ::std::option::Option::Some(main_response::Message::SetIrq(is.read_message()?));
                },
                106 => {
                    self.message = ::std::option::Option::Some(main_response::Message::SetIrqRouting(is.read_message()?));
                },
                114 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetState(is.read_message()?));
                },
                122 => {
                    self.message = ::std::option::Option::Some(main_response::Message::SetState(is.read_message()?));
                },
                130 => {
                    self.message = ::std::option::Option::Some(main_response::Message::SetIdentityMapAddr(is.read_message()?));
                },
                138 => {
                    self.message = ::std::option::Option::Some(main_response::Message::PauseVcpus(is.read_message()?));
                },
                146 => {
                    self.message = ::std::option::Option::Some(main_response::Message::GetVcpus(is.read_message()?));
                },
                154 => {
                    self.message = ::std::option::Option::Some(main_response::Message::Start(is.read_message()?));
                },
                162 => {
                    self.message = ::std::option::Option::Some(main_response::Message::SetCallHint(is.read_message()?));
                },
                810 => {
                    self.message = ::std::option::Option::Some(main_response::Message::DirtyLog(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.errno != 0 {
            my_size += ::protobuf::rt::sint32_size(1, self.errno);
        }
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &main_response::Message::Create(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::Destroy(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::NewConnection(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetShutdownEventfd(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::CheckExtension(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetSupportedCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetEmulatedCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetMsrIndexList(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetNetConfig(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::ReserveRange(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::SetIrq(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::SetIrqRouting(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::SetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::SetIdentityMapAddr(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::PauseVcpus(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::GetVcpus(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::Start(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::SetCallHint(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &main_response::Message::DirtyLog(ref v) => {
                    let len = v.compute_size();
                    my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.errno != 0 {
            os.write_sint32(1, self.errno)?;
        }
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &main_response::Message::Create(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &main_response::Message::Destroy(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &main_response::Message::NewConnection(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &main_response::Message::GetShutdownEventfd(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &main_response::Message::CheckExtension(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &main_response::Message::GetSupportedCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &main_response::Message::GetEmulatedCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &main_response::Message::GetMsrIndexList(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                },
                &main_response::Message::GetNetConfig(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                },
                &main_response::Message::ReserveRange(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
                },
                &main_response::Message::SetIrq(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
                },
                &main_response::Message::SetIrqRouting(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
                },
                &main_response::Message::GetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
                },
                &main_response::Message::SetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(15, v, os)?;
                },
                &main_response::Message::SetIdentityMapAddr(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
                },
                &main_response::Message::PauseVcpus(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(17, v, os)?;
                },
                &main_response::Message::GetVcpus(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
                },
                &main_response::Message::Start(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
                },
                &main_response::Message::SetCallHint(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
                },
                &main_response::Message::DirtyLog(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(101, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.errno = 0;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static MainResponse {
        static instance: MainResponse = MainResponse {
            errno: 0,
            message: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for MainResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("MainResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for MainResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `MainResponse`
pub mod main_response {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:MainResponse.message)
    pub enum Message {
        // @@protoc_insertion_point(oneof_field:MainResponse.create)
        Create(Create),
        // @@protoc_insertion_point(oneof_field:MainResponse.destroy)
        Destroy(Destroy),
        // @@protoc_insertion_point(oneof_field:MainResponse.new_connection)
        NewConnection(NewConnection),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_shutdown_eventfd)
        GetShutdownEventfd(GetShutdownEventfd),
        // @@protoc_insertion_point(oneof_field:MainResponse.check_extension)
        CheckExtension(CheckExtension),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_supported_cpuid)
        GetSupportedCpuid(CpuidResponse),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_emulated_cpuid)
        GetEmulatedCpuid(CpuidResponse),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_msr_index_list)
        GetMsrIndexList(MsrListResponse),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_net_config)
        GetNetConfig(GetNetConfig),
        // @@protoc_insertion_point(oneof_field:MainResponse.reserve_range)
        ReserveRange(ReserveRange),
        // @@protoc_insertion_point(oneof_field:MainResponse.set_irq)
        SetIrq(SetIrq),
        // @@protoc_insertion_point(oneof_field:MainResponse.set_irq_routing)
        SetIrqRouting(SetIrqRouting),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_state)
        GetState(GetState),
        // @@protoc_insertion_point(oneof_field:MainResponse.set_state)
        SetState(SetState),
        // @@protoc_insertion_point(oneof_field:MainResponse.set_identity_map_addr)
        SetIdentityMapAddr(SetIdentityMapAddr),
        // @@protoc_insertion_point(oneof_field:MainResponse.pause_vcpus)
        PauseVcpus(PauseVcpus),
        // @@protoc_insertion_point(oneof_field:MainResponse.get_vcpus)
        GetVcpus(GetVcpus),
        // @@protoc_insertion_point(oneof_field:MainResponse.start)
        Start(Start),
        // @@protoc_insertion_point(oneof_field:MainResponse.set_call_hint)
        SetCallHint(SetCallHint),
        // @@protoc_insertion_point(oneof_field:MainResponse.dirty_log)
        DirtyLog(MemoryDirtyLog),
    }

    impl ::protobuf::Oneof for Message {
    }

    impl ::protobuf::OneofFull for Message {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::MainResponse as ::protobuf::MessageFull>::descriptor().oneof_by_name("message").unwrap()).clone()
        }
    }

    impl Message {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Message>("message")
        }
    }
    // @@protoc_insertion_point(message:MainResponse.Create)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Create {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.Create.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Create>(
                "MainResponse.Create",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Create {
        const NAME: &'static str = "Create";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Create {
            static instance: Create = Create {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Create {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.Create").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Create {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.Destroy)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Destroy {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.Destroy.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Destroy>(
                "MainResponse.Destroy",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Destroy {
        const NAME: &'static str = "Destroy";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Destroy {
            static instance: Destroy = Destroy {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Destroy {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.Destroy").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Destroy {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.NewConnection)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct NewConnection {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.NewConnection.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NewConnection>(
                "MainResponse.NewConnection",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for NewConnection {
        const NAME: &'static str = "NewConnection";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static NewConnection {
            static instance: NewConnection = NewConnection {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for NewConnection {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.NewConnection").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for NewConnection {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.GetShutdownEventfd)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetShutdownEventfd {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.GetShutdownEventfd.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetShutdownEventfd>(
                "MainResponse.GetShutdownEventfd",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetShutdownEventfd {
        const NAME: &'static str = "GetShutdownEventfd";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetShutdownEventfd {
            static instance: GetShutdownEventfd = GetShutdownEventfd {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetShutdownEventfd {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.GetShutdownEventfd").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetShutdownEventfd {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.CheckExtension)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CheckExtension {
        // message fields
        // @@protoc_insertion_point(field:MainResponse.CheckExtension.has_extension)
        pub has_extension: bool,
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.CheckExtension.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "has_extension",
                |m: &CheckExtension| { &m.has_extension },
                |m: &mut CheckExtension| { &mut m.has_extension },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CheckExtension>(
                "MainResponse.CheckExtension",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for CheckExtension {
        const NAME: &'static str = "CheckExtension";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.has_extension = is.read_bool()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.has_extension != false {
                my_size += 1 + 1;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.has_extension != false {
                os.write_bool(1, self.has_extension)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.has_extension = false;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static CheckExtension {
            static instance: CheckExtension = CheckExtension {
                has_extension: false,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for CheckExtension {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.CheckExtension").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for CheckExtension {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.CpuidResponse)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CpuidResponse {
        // message fields
        // @@protoc_insertion_point(field:MainResponse.CpuidResponse.entries)
        pub entries: ::std::vec::Vec<super::CpuidEntry>,
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.CpuidResponse.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "entries",
                |m: &CpuidResponse| { &m.entries },
                |m: &mut CpuidResponse| { &mut m.entries },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CpuidResponse>(
                "MainResponse.CpuidResponse",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for CpuidResponse {
        const NAME: &'static str = "CpuidResponse";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.entries.push(is.read_message()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            for value in &self.entries {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            for v in &self.entries {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.entries.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static CpuidResponse {
            static instance: CpuidResponse = CpuidResponse {
                entries: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for CpuidResponse {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.CpuidResponse").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for CpuidResponse {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.MsrListResponse)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MsrListResponse {
        // message fields
        // @@protoc_insertion_point(field:MainResponse.MsrListResponse.indices)
        pub indices: ::std::vec::Vec<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.MsrListResponse.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "indices",
                |m: &MsrListResponse| { &m.indices },
                |m: &mut MsrListResponse| { &mut m.indices },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MsrListResponse>(
                "MainResponse.MsrListResponse",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for MsrListResponse {
        const NAME: &'static str = "MsrListResponse";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        is.read_repeated_packed_uint32_into(&mut self.indices)?;
                    },
                    8 => {
                        self.indices.push(is.read_uint32()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            os.write_repeated_packed_uint32(1, &self.indices)?;
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.indices.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static MsrListResponse {
            static instance: MsrListResponse = MsrListResponse {
                indices: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for MsrListResponse {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.MsrListResponse").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for MsrListResponse {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.GetNetConfig)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetNetConfig {
        // message fields
        // @@protoc_insertion_point(field:MainResponse.GetNetConfig.host_mac_address)
        pub host_mac_address: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:MainResponse.GetNetConfig.host_ipv4_address)
        pub host_ipv4_address: u32,
        // @@protoc_insertion_point(field:MainResponse.GetNetConfig.netmask)
        pub netmask: u32,
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.GetNetConfig.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(3);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "host_mac_address",
                |m: &GetNetConfig| { &m.host_mac_address },
                |m: &mut GetNetConfig| { &mut m.host_mac_address },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "host_ipv4_address",
                |m: &GetNetConfig| { &m.host_ipv4_address },
                |m: &mut GetNetConfig| { &mut m.host_ipv4_address },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "netmask",
                |m: &GetNetConfig| { &m.netmask },
                |m: &mut GetNetConfig| { &mut m.netmask },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetNetConfig>(
                "MainResponse.GetNetConfig",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetNetConfig {
        const NAME: &'static str = "GetNetConfig";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.host_mac_address = is.read_bytes()?;
                    },
                    21 => {
                        self.host_ipv4_address = is.read_fixed32()?;
                    },
                    29 => {
                        self.netmask = is.read_fixed32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.host_mac_address.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.host_mac_address);
            }
            if self.host_ipv4_address != 0 {
                my_size += 1 + 4;
            }
            if self.netmask != 0 {
                my_size += 1 + 4;
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.host_mac_address.is_empty() {
                os.write_bytes(1, &self.host_mac_address)?;
            }
            if self.host_ipv4_address != 0 {
                os.write_fixed32(2, self.host_ipv4_address)?;
            }
            if self.netmask != 0 {
                os.write_fixed32(3, self.netmask)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.host_mac_address.clear();
            self.host_ipv4_address = 0;
            self.netmask = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetNetConfig {
            static instance: GetNetConfig = GetNetConfig {
                host_mac_address: ::std::vec::Vec::new(),
                host_ipv4_address: 0,
                netmask: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetNetConfig {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.GetNetConfig").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetNetConfig {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.ReserveRange)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct ReserveRange {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.ReserveRange.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ReserveRange>(
                "MainResponse.ReserveRange",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for ReserveRange {
        const NAME: &'static str = "ReserveRange";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static ReserveRange {
            static instance: ReserveRange = ReserveRange {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for ReserveRange {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.ReserveRange").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for ReserveRange {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.SetIrq)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetIrq {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.SetIrq.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetIrq>(
                "MainResponse.SetIrq",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetIrq {
        const NAME: &'static str = "SetIrq";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetIrq {
            static instance: SetIrq = SetIrq {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetIrq {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.SetIrq").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetIrq {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.SetIrqRouting)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetIrqRouting {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.SetIrqRouting.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetIrqRouting>(
                "MainResponse.SetIrqRouting",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetIrqRouting {
        const NAME: &'static str = "SetIrqRouting";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetIrqRouting {
            static instance: SetIrqRouting = SetIrqRouting {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetIrqRouting {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.SetIrqRouting").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetIrqRouting {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.GetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetState {
        // message fields
        // @@protoc_insertion_point(field:MainResponse.GetState.state)
        pub state: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.GetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "state",
                |m: &GetState| { &m.state },
                |m: &mut GetState| { &mut m.state },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetState>(
                "MainResponse.GetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetState {
        const NAME: &'static str = "GetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.state = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.state.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.state);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.state.is_empty() {
                os.write_bytes(1, &self.state)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.state.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetState {
            static instance: GetState = GetState {
                state: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.GetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.SetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetState {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.SetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetState>(
                "MainResponse.SetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetState {
        const NAME: &'static str = "SetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetState {
            static instance: SetState = SetState {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.SetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.SetIdentityMapAddr)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetIdentityMapAddr {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.SetIdentityMapAddr.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetIdentityMapAddr>(
                "MainResponse.SetIdentityMapAddr",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetIdentityMapAddr {
        const NAME: &'static str = "SetIdentityMapAddr";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetIdentityMapAddr {
            static instance: SetIdentityMapAddr = SetIdentityMapAddr {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetIdentityMapAddr {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.SetIdentityMapAddr").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetIdentityMapAddr {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.PauseVcpus)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct PauseVcpus {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.PauseVcpus.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PauseVcpus>(
                "MainResponse.PauseVcpus",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for PauseVcpus {
        const NAME: &'static str = "PauseVcpus";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static PauseVcpus {
            static instance: PauseVcpus = PauseVcpus {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for PauseVcpus {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.PauseVcpus").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for PauseVcpus {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.GetVcpus)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetVcpus {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.GetVcpus.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetVcpus>(
                "MainResponse.GetVcpus",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetVcpus {
        const NAME: &'static str = "GetVcpus";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetVcpus {
            static instance: GetVcpus = GetVcpus {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetVcpus {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.GetVcpus").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetVcpus {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.Start)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Start {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.Start.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Start>(
                "MainResponse.Start",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Start {
        const NAME: &'static str = "Start";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Start {
            static instance: Start = Start {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Start {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.Start").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Start {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.SetCallHint)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetCallHint {
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.SetCallHint.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetCallHint>(
                "MainResponse.SetCallHint",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetCallHint {
        const NAME: &'static str = "SetCallHint";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetCallHint {
            static instance: SetCallHint = SetCallHint {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetCallHint {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.SetCallHint").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetCallHint {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:MainResponse.MemoryDirtyLog)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MemoryDirtyLog {
        // message fields
        // @@protoc_insertion_point(field:MainResponse.MemoryDirtyLog.bitmap)
        pub bitmap: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:MainResponse.MemoryDirtyLog.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "bitmap",
                |m: &MemoryDirtyLog| { &m.bitmap },
                |m: &mut MemoryDirtyLog| { &mut m.bitmap },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MemoryDirtyLog>(
                "MainResponse.MemoryDirtyLog",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for MemoryDirtyLog {
        const NAME: &'static str = "MemoryDirtyLog";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.bitmap = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.bitmap.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.bitmap);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.bitmap.is_empty() {
                os.write_bytes(1, &self.bitmap)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.bitmap.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static MemoryDirtyLog {
            static instance: MemoryDirtyLog = MemoryDirtyLog {
                bitmap: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for MemoryDirtyLog {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("MainResponse.MemoryDirtyLog").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for MemoryDirtyLog {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }
}

// @@protoc_insertion_point(message:VcpuRequest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VcpuRequest {
    // message oneof groups
    pub message: ::std::option::Option<vcpu_request::Message>,
    // special fields
    // @@protoc_insertion_point(special_field:VcpuRequest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .VcpuRequest.Wait wait = 1;

    pub fn wait(&self) -> &vcpu_request::Wait {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Wait(ref v)) => v,
            _ => <vcpu_request::Wait as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_wait(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_wait(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Wait(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_wait(&mut self, v: vcpu_request::Wait) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::Wait(v))
    }

    // Mutable pointer to the field.
    pub fn mut_wait(&mut self) -> &mut vcpu_request::Wait {
        if let ::std::option::Option::Some(vcpu_request::Message::Wait(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::Wait(vcpu_request::Wait::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Wait(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_wait(&mut self) -> vcpu_request::Wait {
        if self.has_wait() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::Wait(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::Wait::new()
        }
    }

    // .VcpuRequest.Resume resume = 2;

    pub fn resume(&self) -> &vcpu_request::Resume {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Resume(ref v)) => v,
            _ => <vcpu_request::Resume as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_resume(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_resume(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Resume(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_resume(&mut self, v: vcpu_request::Resume) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::Resume(v))
    }

    // Mutable pointer to the field.
    pub fn mut_resume(&mut self) -> &mut vcpu_request::Resume {
        if let ::std::option::Option::Some(vcpu_request::Message::Resume(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::Resume(vcpu_request::Resume::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Resume(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_resume(&mut self) -> vcpu_request::Resume {
        if self.has_resume() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::Resume(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::Resume::new()
        }
    }

    // .VcpuRequest.GetState get_state = 3;

    pub fn get_state(&self) -> &vcpu_request::GetState {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetState(ref v)) => v,
            _ => <vcpu_request::GetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_state(&mut self, v: vcpu_request::GetState) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::GetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_state(&mut self) -> &mut vcpu_request::GetState {
        if let ::std::option::Option::Some(vcpu_request::Message::GetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::GetState(vcpu_request::GetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_state(&mut self) -> vcpu_request::GetState {
        if self.has_get_state() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::GetState(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::GetState::new()
        }
    }

    // .VcpuRequest.SetState set_state = 4;

    pub fn set_state(&self) -> &vcpu_request::SetState {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetState(ref v)) => v,
            _ => <vcpu_request::SetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_state(&mut self, v: vcpu_request::SetState) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::SetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_state(&mut self) -> &mut vcpu_request::SetState {
        if let ::std::option::Option::Some(vcpu_request::Message::SetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::SetState(vcpu_request::SetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_state(&mut self) -> vcpu_request::SetState {
        if self.has_set_state() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::SetState(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::SetState::new()
        }
    }

    // .VcpuRequest.GetMsrs get_msrs = 5;

    pub fn get_msrs(&self) -> &vcpu_request::GetMsrs {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetMsrs(ref v)) => v,
            _ => <vcpu_request::GetMsrs as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_msrs(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_msrs(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetMsrs(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_msrs(&mut self, v: vcpu_request::GetMsrs) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::GetMsrs(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_msrs(&mut self) -> &mut vcpu_request::GetMsrs {
        if let ::std::option::Option::Some(vcpu_request::Message::GetMsrs(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::GetMsrs(vcpu_request::GetMsrs::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetMsrs(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_msrs(&mut self) -> vcpu_request::GetMsrs {
        if self.has_get_msrs() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::GetMsrs(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::GetMsrs::new()
        }
    }

    // .VcpuRequest.SetMsrs set_msrs = 6;

    pub fn set_msrs(&self) -> &vcpu_request::SetMsrs {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetMsrs(ref v)) => v,
            _ => <vcpu_request::SetMsrs as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_msrs(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_msrs(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetMsrs(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_msrs(&mut self, v: vcpu_request::SetMsrs) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::SetMsrs(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_msrs(&mut self) -> &mut vcpu_request::SetMsrs {
        if let ::std::option::Option::Some(vcpu_request::Message::SetMsrs(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::SetMsrs(vcpu_request::SetMsrs::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetMsrs(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_msrs(&mut self) -> vcpu_request::SetMsrs {
        if self.has_set_msrs() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::SetMsrs(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::SetMsrs::new()
        }
    }

    // .VcpuRequest.SetCpuid set_cpuid = 7;

    pub fn set_cpuid(&self) -> &vcpu_request::SetCpuid {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetCpuid(ref v)) => v,
            _ => <vcpu_request::SetCpuid as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_cpuid(&mut self, v: vcpu_request::SetCpuid) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::SetCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_cpuid(&mut self) -> &mut vcpu_request::SetCpuid {
        if let ::std::option::Option::Some(vcpu_request::Message::SetCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::SetCpuid(vcpu_request::SetCpuid::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::SetCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_cpuid(&mut self) -> vcpu_request::SetCpuid {
        if self.has_set_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::SetCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::SetCpuid::new()
        }
    }

    // .VcpuRequest.Shutdown shutdown = 8;

    pub fn shutdown(&self) -> &vcpu_request::Shutdown {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Shutdown(ref v)) => v,
            _ => <vcpu_request::Shutdown as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_shutdown(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_shutdown(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Shutdown(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_shutdown(&mut self, v: vcpu_request::Shutdown) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::Shutdown(v))
    }

    // Mutable pointer to the field.
    pub fn mut_shutdown(&mut self) -> &mut vcpu_request::Shutdown {
        if let ::std::option::Option::Some(vcpu_request::Message::Shutdown(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::Shutdown(vcpu_request::Shutdown::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::Shutdown(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_shutdown(&mut self) -> vcpu_request::Shutdown {
        if self.has_shutdown() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::Shutdown(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::Shutdown::new()
        }
    }

    // .VcpuRequest.CpuidRequest get_hyperv_cpuid = 9;

    pub fn get_hyperv_cpuid(&self) -> &vcpu_request::CpuidRequest {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(ref v)) => v,
            _ => <vcpu_request::CpuidRequest as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_hyperv_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_hyperv_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_hyperv_cpuid(&mut self, v: vcpu_request::CpuidRequest) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_hyperv_cpuid(&mut self) -> &mut vcpu_request::CpuidRequest {
        if let ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(vcpu_request::CpuidRequest::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_hyperv_cpuid(&mut self) -> vcpu_request::CpuidRequest {
        if self.has_get_hyperv_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::CpuidRequest::new()
        }
    }

    // .VcpuRequest.EnableCapability enable_capability = 10;

    pub fn enable_capability(&self) -> &vcpu_request::EnableCapability {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::EnableCapability(ref v)) => v,
            _ => <vcpu_request::EnableCapability as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_enable_capability(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_enable_capability(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::EnableCapability(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_enable_capability(&mut self, v: vcpu_request::EnableCapability) {
        self.message = ::std::option::Option::Some(vcpu_request::Message::EnableCapability(v))
    }

    // Mutable pointer to the field.
    pub fn mut_enable_capability(&mut self) -> &mut vcpu_request::EnableCapability {
        if let ::std::option::Option::Some(vcpu_request::Message::EnableCapability(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_request::Message::EnableCapability(vcpu_request::EnableCapability::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_request::Message::EnableCapability(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_enable_capability(&mut self) -> vcpu_request::EnableCapability {
        if self.has_enable_capability() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_request::Message::EnableCapability(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_request::EnableCapability::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(10);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::Wait>(
            "wait",
            VcpuRequest::has_wait,
            VcpuRequest::wait,
            VcpuRequest::mut_wait,
            VcpuRequest::set_wait,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::Resume>(
            "resume",
            VcpuRequest::has_resume,
            VcpuRequest::resume,
            VcpuRequest::mut_resume,
            VcpuRequest::set_resume,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::GetState>(
            "get_state",
            VcpuRequest::has_get_state,
            VcpuRequest::get_state,
            VcpuRequest::mut_get_state,
            VcpuRequest::set_get_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::SetState>(
            "set_state",
            VcpuRequest::has_set_state,
            VcpuRequest::set_state,
            VcpuRequest::mut_set_state,
            VcpuRequest::set_set_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::GetMsrs>(
            "get_msrs",
            VcpuRequest::has_get_msrs,
            VcpuRequest::get_msrs,
            VcpuRequest::mut_get_msrs,
            VcpuRequest::set_get_msrs,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::SetMsrs>(
            "set_msrs",
            VcpuRequest::has_set_msrs,
            VcpuRequest::set_msrs,
            VcpuRequest::mut_set_msrs,
            VcpuRequest::set_set_msrs,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::SetCpuid>(
            "set_cpuid",
            VcpuRequest::has_set_cpuid,
            VcpuRequest::set_cpuid,
            VcpuRequest::mut_set_cpuid,
            VcpuRequest::set_set_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::Shutdown>(
            "shutdown",
            VcpuRequest::has_shutdown,
            VcpuRequest::shutdown,
            VcpuRequest::mut_shutdown,
            VcpuRequest::set_shutdown,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::CpuidRequest>(
            "get_hyperv_cpuid",
            VcpuRequest::has_get_hyperv_cpuid,
            VcpuRequest::get_hyperv_cpuid,
            VcpuRequest::mut_get_hyperv_cpuid,
            VcpuRequest::set_get_hyperv_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_request::EnableCapability>(
            "enable_capability",
            VcpuRequest::has_enable_capability,
            VcpuRequest::enable_capability,
            VcpuRequest::mut_enable_capability,
            VcpuRequest::set_enable_capability,
        ));
        oneofs.push(vcpu_request::Message::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VcpuRequest>(
            "VcpuRequest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for VcpuRequest {
    const NAME: &'static str = "VcpuRequest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::Wait(is.read_message()?));
                },
                18 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::Resume(is.read_message()?));
                },
                26 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::GetState(is.read_message()?));
                },
                34 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::SetState(is.read_message()?));
                },
                42 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::GetMsrs(is.read_message()?));
                },
                50 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::SetMsrs(is.read_message()?));
                },
                58 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::SetCpuid(is.read_message()?));
                },
                66 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::Shutdown(is.read_message()?));
                },
                74 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::GetHypervCpuid(is.read_message()?));
                },
                82 => {
                    self.message = ::std::option::Option::Some(vcpu_request::Message::EnableCapability(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &vcpu_request::Message::Wait(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::Resume(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::GetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::SetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::GetMsrs(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::SetMsrs(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::SetCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::Shutdown(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::GetHypervCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_request::Message::EnableCapability(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &vcpu_request::Message::Wait(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                },
                &vcpu_request::Message::Resume(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &vcpu_request::Message::GetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                },
                &vcpu_request::Message::SetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &vcpu_request::Message::GetMsrs(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &vcpu_request::Message::SetMsrs(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &vcpu_request::Message::SetCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &vcpu_request::Message::Shutdown(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &vcpu_request::Message::GetHypervCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                },
                &vcpu_request::Message::EnableCapability(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static VcpuRequest {
        static instance: VcpuRequest = VcpuRequest {
            message: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for VcpuRequest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("VcpuRequest").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for VcpuRequest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `VcpuRequest`
pub mod vcpu_request {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:VcpuRequest.message)
    pub enum Message {
        // @@protoc_insertion_point(oneof_field:VcpuRequest.wait)
        Wait(Wait),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.resume)
        Resume(Resume),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.get_state)
        GetState(GetState),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.set_state)
        SetState(SetState),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.get_msrs)
        GetMsrs(GetMsrs),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.set_msrs)
        SetMsrs(SetMsrs),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.set_cpuid)
        SetCpuid(SetCpuid),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.shutdown)
        Shutdown(Shutdown),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.get_hyperv_cpuid)
        GetHypervCpuid(CpuidRequest),
        // @@protoc_insertion_point(oneof_field:VcpuRequest.enable_capability)
        EnableCapability(EnableCapability),
    }

    impl ::protobuf::Oneof for Message {
    }

    impl ::protobuf::OneofFull for Message {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::VcpuRequest as ::protobuf::MessageFull>::descriptor().oneof_by_name("message").unwrap()).clone()
        }
    }

    impl Message {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Message>("message")
        }
    }
    // @@protoc_insertion_point(message:VcpuRequest.Wait)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Wait {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.Wait.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Wait>(
                "VcpuRequest.Wait",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Wait {
        const NAME: &'static str = "Wait";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Wait {
            static instance: Wait = Wait {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Wait {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.Wait").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Wait {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.Resume)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Resume {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.Resume.data)
        pub data: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:VcpuRequest.Resume.regs)
        pub regs: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:VcpuRequest.Resume.sregs)
        pub sregs: ::std::vec::Vec<u8>,
        // @@protoc_insertion_point(field:VcpuRequest.Resume.debugregs)
        pub debugregs: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.Resume.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(4);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "data",
                |m: &Resume| { &m.data },
                |m: &mut Resume| { &mut m.data },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "regs",
                |m: &Resume| { &m.regs },
                |m: &mut Resume| { &mut m.regs },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "sregs",
                |m: &Resume| { &m.sregs },
                |m: &mut Resume| { &mut m.sregs },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "debugregs",
                |m: &Resume| { &m.debugregs },
                |m: &mut Resume| { &mut m.debugregs },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Resume>(
                "VcpuRequest.Resume",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Resume {
        const NAME: &'static str = "Resume";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.data = is.read_bytes()?;
                    },
                    18 => {
                        self.regs = is.read_bytes()?;
                    },
                    26 => {
                        self.sregs = is.read_bytes()?;
                    },
                    34 => {
                        self.debugregs = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.data.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.data);
            }
            if !self.regs.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.regs);
            }
            if !self.sregs.is_empty() {
                my_size += ::protobuf::rt::bytes_size(3, &self.sregs);
            }
            if !self.debugregs.is_empty() {
                my_size += ::protobuf::rt::bytes_size(4, &self.debugregs);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.data.is_empty() {
                os.write_bytes(1, &self.data)?;
            }
            if !self.regs.is_empty() {
                os.write_bytes(2, &self.regs)?;
            }
            if !self.sregs.is_empty() {
                os.write_bytes(3, &self.sregs)?;
            }
            if !self.debugregs.is_empty() {
                os.write_bytes(4, &self.debugregs)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.data.clear();
            self.regs.clear();
            self.sregs.clear();
            self.debugregs.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Resume {
            static instance: Resume = Resume {
                data: ::std::vec::Vec::new(),
                regs: ::std::vec::Vec::new(),
                sregs: ::std::vec::Vec::new(),
                debugregs: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Resume {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.Resume").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Resume {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.GetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetState {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.GetState.set)
        pub set: ::protobuf::EnumOrUnknown<StateSet>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.GetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "set",
                |m: &GetState| { &m.set },
                |m: &mut GetState| { &mut m.set },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetState>(
                "VcpuRequest.GetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetState {
        const NAME: &'static str = "GetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.set = is.read_enum_or_unknown()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::REGS) {
                my_size += ::protobuf::rt::int32_size(1, self.set.value());
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::REGS) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.set))?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.set = ::protobuf::EnumOrUnknown::new(StateSet::REGS);
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetState {
            static instance: GetState = GetState {
                set: ::protobuf::EnumOrUnknown::from_i32(0),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.GetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.SetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetState {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.SetState.set)
        pub set: ::protobuf::EnumOrUnknown<StateSet>,
        // @@protoc_insertion_point(field:VcpuRequest.SetState.state)
        pub state: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.SetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(2);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "set",
                |m: &SetState| { &m.set },
                |m: &mut SetState| { &mut m.set },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "state",
                |m: &SetState| { &m.state },
                |m: &mut SetState| { &mut m.state },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetState>(
                "VcpuRequest.SetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetState {
        const NAME: &'static str = "SetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.set = is.read_enum_or_unknown()?;
                    },
                    18 => {
                        self.state = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::REGS) {
                my_size += ::protobuf::rt::int32_size(1, self.set.value());
            }
            if !self.state.is_empty() {
                my_size += ::protobuf::rt::bytes_size(2, &self.state);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.set != ::protobuf::EnumOrUnknown::new(StateSet::REGS) {
                os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.set))?;
            }
            if !self.state.is_empty() {
                os.write_bytes(2, &self.state)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.set = ::protobuf::EnumOrUnknown::new(StateSet::REGS);
            self.state.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetState {
            static instance: SetState = SetState {
                set: ::protobuf::EnumOrUnknown::from_i32(0),
                state: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.SetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.CpuidRequest)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CpuidRequest {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.CpuidRequest.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CpuidRequest>(
                "VcpuRequest.CpuidRequest",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for CpuidRequest {
        const NAME: &'static str = "CpuidRequest";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static CpuidRequest {
            static instance: CpuidRequest = CpuidRequest {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for CpuidRequest {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.CpuidRequest").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for CpuidRequest {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.GetMsrs)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetMsrs {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.GetMsrs.entry_indices)
        pub entry_indices: ::std::vec::Vec<u32>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.GetMsrs.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "entry_indices",
                |m: &GetMsrs| { &m.entry_indices },
                |m: &mut GetMsrs| { &mut m.entry_indices },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetMsrs>(
                "VcpuRequest.GetMsrs",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetMsrs {
        const NAME: &'static str = "GetMsrs";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        is.read_repeated_packed_uint32_into(&mut self.entry_indices)?;
                    },
                    8 => {
                        self.entry_indices.push(is.read_uint32()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            os.write_repeated_packed_uint32(1, &self.entry_indices)?;
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.entry_indices.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetMsrs {
            static instance: GetMsrs = GetMsrs {
                entry_indices: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetMsrs {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.GetMsrs").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetMsrs {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.MsrEntry)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct MsrEntry {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.MsrEntry.index)
        pub index: u32,
        // @@protoc_insertion_point(field:VcpuRequest.MsrEntry.data)
        pub data: u64,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.MsrEntry.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(2);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "index",
                |m: &MsrEntry| { &m.index },
                |m: &mut MsrEntry| { &mut m.index },
            ));
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "data",
                |m: &MsrEntry| { &m.data },
                |m: &mut MsrEntry| { &mut m.data },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MsrEntry>(
                "VcpuRequest.MsrEntry",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for MsrEntry {
        const NAME: &'static str = "MsrEntry";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.index = is.read_uint32()?;
                    },
                    16 => {
                        self.data = is.read_uint64()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.index != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.index);
            }
            if self.data != 0 {
                my_size += ::protobuf::rt::uint64_size(2, self.data);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.index != 0 {
                os.write_uint32(1, self.index)?;
            }
            if self.data != 0 {
                os.write_uint64(2, self.data)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.index = 0;
            self.data = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static MsrEntry {
            static instance: MsrEntry = MsrEntry {
                index: 0,
                data: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for MsrEntry {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.MsrEntry").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for MsrEntry {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.SetMsrs)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetMsrs {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.SetMsrs.entries)
        pub entries: ::std::vec::Vec<MsrEntry>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.SetMsrs.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "entries",
                |m: &SetMsrs| { &m.entries },
                |m: &mut SetMsrs| { &mut m.entries },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetMsrs>(
                "VcpuRequest.SetMsrs",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetMsrs {
        const NAME: &'static str = "SetMsrs";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.entries.push(is.read_message()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            for value in &self.entries {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            for v in &self.entries {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.entries.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetMsrs {
            static instance: SetMsrs = SetMsrs {
                entries: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetMsrs {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.SetMsrs").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetMsrs {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.SetCpuid)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetCpuid {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.SetCpuid.entries)
        pub entries: ::std::vec::Vec<super::CpuidEntry>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.SetCpuid.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "entries",
                |m: &SetCpuid| { &m.entries },
                |m: &mut SetCpuid| { &mut m.entries },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetCpuid>(
                "VcpuRequest.SetCpuid",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetCpuid {
        const NAME: &'static str = "SetCpuid";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.entries.push(is.read_message()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            for value in &self.entries {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            for v in &self.entries {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.entries.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetCpuid {
            static instance: SetCpuid = SetCpuid {
                entries: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetCpuid {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.SetCpuid").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetCpuid {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.Shutdown)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Shutdown {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.Shutdown.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Shutdown>(
                "VcpuRequest.Shutdown",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Shutdown {
        const NAME: &'static str = "Shutdown";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Shutdown {
            static instance: Shutdown = Shutdown {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Shutdown {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.Shutdown").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Shutdown {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuRequest.EnableCapability)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct EnableCapability {
        // message fields
        // @@protoc_insertion_point(field:VcpuRequest.EnableCapability.capability)
        pub capability: u32,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuRequest.EnableCapability.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "capability",
                |m: &EnableCapability| { &m.capability },
                |m: &mut EnableCapability| { &mut m.capability },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnableCapability>(
                "VcpuRequest.EnableCapability",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for EnableCapability {
        const NAME: &'static str = "EnableCapability";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    8 => {
                        self.capability = is.read_uint32()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if self.capability != 0 {
                my_size += ::protobuf::rt::uint32_size(1, self.capability);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if self.capability != 0 {
                os.write_uint32(1, self.capability)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.capability = 0;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static EnableCapability {
            static instance: EnableCapability = EnableCapability {
                capability: 0,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for EnableCapability {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuRequest.EnableCapability").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for EnableCapability {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:VcpuRequest.StateSet)
    pub enum StateSet {
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.REGS)
        REGS = 0,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.SREGS)
        SREGS = 1,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.FPU)
        FPU = 2,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.DEBUGREGS)
        DEBUGREGS = 3,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.LAPIC)
        LAPIC = 4,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.MP)
        MP = 5,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.XCREGS)
        XCREGS = 6,
        // @@protoc_insertion_point(enum_value:VcpuRequest.StateSet.EVENTS)
        EVENTS = 7,
    }

    impl ::protobuf::Enum for StateSet {
        const NAME: &'static str = "StateSet";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<StateSet> {
            match value {
                0 => ::std::option::Option::Some(StateSet::REGS),
                1 => ::std::option::Option::Some(StateSet::SREGS),
                2 => ::std::option::Option::Some(StateSet::FPU),
                3 => ::std::option::Option::Some(StateSet::DEBUGREGS),
                4 => ::std::option::Option::Some(StateSet::LAPIC),
                5 => ::std::option::Option::Some(StateSet::MP),
                6 => ::std::option::Option::Some(StateSet::XCREGS),
                7 => ::std::option::Option::Some(StateSet::EVENTS),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<StateSet> {
            match str {
                "REGS" => ::std::option::Option::Some(StateSet::REGS),
                "SREGS" => ::std::option::Option::Some(StateSet::SREGS),
                "FPU" => ::std::option::Option::Some(StateSet::FPU),
                "DEBUGREGS" => ::std::option::Option::Some(StateSet::DEBUGREGS),
                "LAPIC" => ::std::option::Option::Some(StateSet::LAPIC),
                "MP" => ::std::option::Option::Some(StateSet::MP),
                "XCREGS" => ::std::option::Option::Some(StateSet::XCREGS),
                "EVENTS" => ::std::option::Option::Some(StateSet::EVENTS),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [StateSet] = &[
            StateSet::REGS,
            StateSet::SREGS,
            StateSet::FPU,
            StateSet::DEBUGREGS,
            StateSet::LAPIC,
            StateSet::MP,
            StateSet::XCREGS,
            StateSet::EVENTS,
        ];
    }

    impl ::protobuf::EnumFull for StateSet {
        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("VcpuRequest.StateSet").unwrap()).clone()
        }

        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
            let index = *self as usize;
            Self::enum_descriptor().value_by_index(index)
        }
    }

    impl ::std::default::Default for StateSet {
        fn default() -> Self {
            StateSet::REGS
        }
    }

    impl StateSet {
        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<StateSet>("VcpuRequest.StateSet")
        }
    }
}

// @@protoc_insertion_point(message:VcpuResponse)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VcpuResponse {
    // message fields
    // @@protoc_insertion_point(field:VcpuResponse.errno)
    pub errno: i32,
    // message oneof groups
    pub message: ::std::option::Option<vcpu_response::Message>,
    // special fields
    // @@protoc_insertion_point(special_field:VcpuResponse.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // .VcpuResponse.Wait wait = 2;

    pub fn wait(&self) -> &vcpu_response::Wait {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::Wait(ref v)) => v,
            _ => <vcpu_response::Wait as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_wait(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_wait(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::Wait(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_wait(&mut self, v: vcpu_response::Wait) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::Wait(v))
    }

    // Mutable pointer to the field.
    pub fn mut_wait(&mut self) -> &mut vcpu_response::Wait {
        if let ::std::option::Option::Some(vcpu_response::Message::Wait(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::Wait(vcpu_response::Wait::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::Wait(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_wait(&mut self) -> vcpu_response::Wait {
        if self.has_wait() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::Wait(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::Wait::new()
        }
    }

    // .VcpuResponse.GetState get_state = 4;

    pub fn get_state(&self) -> &vcpu_response::GetState {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetState(ref v)) => v,
            _ => <vcpu_response::GetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_state(&mut self, v: vcpu_response::GetState) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::GetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_state(&mut self) -> &mut vcpu_response::GetState {
        if let ::std::option::Option::Some(vcpu_response::Message::GetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::GetState(vcpu_response::GetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_state(&mut self) -> vcpu_response::GetState {
        if self.has_get_state() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::GetState(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::GetState::new()
        }
    }

    // .VcpuResponse.SetState set_state = 5;

    pub fn set_state(&self) -> &vcpu_response::SetState {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetState(ref v)) => v,
            _ => <vcpu_response::SetState as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_state(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_state(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetState(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_state(&mut self, v: vcpu_response::SetState) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::SetState(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_state(&mut self) -> &mut vcpu_response::SetState {
        if let ::std::option::Option::Some(vcpu_response::Message::SetState(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::SetState(vcpu_response::SetState::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetState(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_state(&mut self) -> vcpu_response::SetState {
        if self.has_set_state() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::SetState(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::SetState::new()
        }
    }

    // .VcpuResponse.GetMsrs get_msrs = 6;

    pub fn get_msrs(&self) -> &vcpu_response::GetMsrs {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetMsrs(ref v)) => v,
            _ => <vcpu_response::GetMsrs as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_msrs(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_msrs(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetMsrs(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_msrs(&mut self, v: vcpu_response::GetMsrs) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::GetMsrs(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_msrs(&mut self) -> &mut vcpu_response::GetMsrs {
        if let ::std::option::Option::Some(vcpu_response::Message::GetMsrs(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::GetMsrs(vcpu_response::GetMsrs::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetMsrs(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_msrs(&mut self) -> vcpu_response::GetMsrs {
        if self.has_get_msrs() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::GetMsrs(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::GetMsrs::new()
        }
    }

    // .VcpuResponse.SetMsrs set_msrs = 7;

    pub fn set_msrs(&self) -> &vcpu_response::SetMsrs {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetMsrs(ref v)) => v,
            _ => <vcpu_response::SetMsrs as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_msrs(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_msrs(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetMsrs(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_msrs(&mut self, v: vcpu_response::SetMsrs) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::SetMsrs(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_msrs(&mut self) -> &mut vcpu_response::SetMsrs {
        if let ::std::option::Option::Some(vcpu_response::Message::SetMsrs(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::SetMsrs(vcpu_response::SetMsrs::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetMsrs(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_msrs(&mut self) -> vcpu_response::SetMsrs {
        if self.has_set_msrs() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::SetMsrs(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::SetMsrs::new()
        }
    }

    // .VcpuResponse.SetCpuid set_cpuid = 8;

    pub fn set_cpuid(&self) -> &vcpu_response::SetCpuid {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetCpuid(ref v)) => v,
            _ => <vcpu_response::SetCpuid as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_set_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_set_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_cpuid(&mut self, v: vcpu_response::SetCpuid) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::SetCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_cpuid(&mut self) -> &mut vcpu_response::SetCpuid {
        if let ::std::option::Option::Some(vcpu_response::Message::SetCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::SetCpuid(vcpu_response::SetCpuid::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::SetCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_cpuid(&mut self) -> vcpu_response::SetCpuid {
        if self.has_set_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::SetCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::SetCpuid::new()
        }
    }

    // .VcpuResponse.CpuidResponse get_hyperv_cpuid = 9;

    pub fn get_hyperv_cpuid(&self) -> &vcpu_response::CpuidResponse {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(ref v)) => v,
            _ => <vcpu_response::CpuidResponse as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_get_hyperv_cpuid(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_get_hyperv_cpuid(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_get_hyperv_cpuid(&mut self, v: vcpu_response::CpuidResponse) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(v))
    }

    // Mutable pointer to the field.
    pub fn mut_get_hyperv_cpuid(&mut self) -> &mut vcpu_response::CpuidResponse {
        if let ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(vcpu_response::CpuidResponse::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_get_hyperv_cpuid(&mut self) -> vcpu_response::CpuidResponse {
        if self.has_get_hyperv_cpuid() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::CpuidResponse::new()
        }
    }

    // .VcpuResponse.EnableCapability enable_capability = 10;

    pub fn enable_capability(&self) -> &vcpu_response::EnableCapability {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::EnableCapability(ref v)) => v,
            _ => <vcpu_response::EnableCapability as ::protobuf::Message>::default_instance(),
        }
    }

    pub fn clear_enable_capability(&mut self) {
        self.message = ::std::option::Option::None;
    }

    pub fn has_enable_capability(&self) -> bool {
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::EnableCapability(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_enable_capability(&mut self, v: vcpu_response::EnableCapability) {
        self.message = ::std::option::Option::Some(vcpu_response::Message::EnableCapability(v))
    }

    // Mutable pointer to the field.
    pub fn mut_enable_capability(&mut self) -> &mut vcpu_response::EnableCapability {
        if let ::std::option::Option::Some(vcpu_response::Message::EnableCapability(_)) = self.message {
        } else {
            self.message = ::std::option::Option::Some(vcpu_response::Message::EnableCapability(vcpu_response::EnableCapability::new()));
        }
        match self.message {
            ::std::option::Option::Some(vcpu_response::Message::EnableCapability(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_enable_capability(&mut self) -> vcpu_response::EnableCapability {
        if self.has_enable_capability() {
            match self.message.take() {
                ::std::option::Option::Some(vcpu_response::Message::EnableCapability(v)) => v,
                _ => panic!(),
            }
        } else {
            vcpu_response::EnableCapability::new()
        }
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(9);
        let mut oneofs = ::std::vec::Vec::with_capacity(1);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "errno",
            |m: &VcpuResponse| { &m.errno },
            |m: &mut VcpuResponse| { &mut m.errno },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::Wait>(
            "wait",
            VcpuResponse::has_wait,
            VcpuResponse::wait,
            VcpuResponse::mut_wait,
            VcpuResponse::set_wait,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::GetState>(
            "get_state",
            VcpuResponse::has_get_state,
            VcpuResponse::get_state,
            VcpuResponse::mut_get_state,
            VcpuResponse::set_get_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::SetState>(
            "set_state",
            VcpuResponse::has_set_state,
            VcpuResponse::set_state,
            VcpuResponse::mut_set_state,
            VcpuResponse::set_set_state,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::GetMsrs>(
            "get_msrs",
            VcpuResponse::has_get_msrs,
            VcpuResponse::get_msrs,
            VcpuResponse::mut_get_msrs,
            VcpuResponse::set_get_msrs,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::SetMsrs>(
            "set_msrs",
            VcpuResponse::has_set_msrs,
            VcpuResponse::set_msrs,
            VcpuResponse::mut_set_msrs,
            VcpuResponse::set_set_msrs,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::SetCpuid>(
            "set_cpuid",
            VcpuResponse::has_set_cpuid,
            VcpuResponse::set_cpuid,
            VcpuResponse::mut_set_cpuid,
            VcpuResponse::set_set_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::CpuidResponse>(
            "get_hyperv_cpuid",
            VcpuResponse::has_get_hyperv_cpuid,
            VcpuResponse::get_hyperv_cpuid,
            VcpuResponse::mut_get_hyperv_cpuid,
            VcpuResponse::set_get_hyperv_cpuid,
        ));
        fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, vcpu_response::EnableCapability>(
            "enable_capability",
            VcpuResponse::has_enable_capability,
            VcpuResponse::enable_capability,
            VcpuResponse::mut_enable_capability,
            VcpuResponse::set_enable_capability,
        ));
        oneofs.push(vcpu_response::Message::generated_oneof_descriptor_data());
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VcpuResponse>(
            "VcpuResponse",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for VcpuResponse {
    const NAME: &'static str = "VcpuResponse";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.errno = is.read_sint32()?;
                },
                18 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::Wait(is.read_message()?));
                },
                34 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::GetState(is.read_message()?));
                },
                42 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::SetState(is.read_message()?));
                },
                50 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::GetMsrs(is.read_message()?));
                },
                58 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::SetMsrs(is.read_message()?));
                },
                66 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::SetCpuid(is.read_message()?));
                },
                74 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::GetHypervCpuid(is.read_message()?));
                },
                82 => {
                    self.message = ::std::option::Option::Some(vcpu_response::Message::EnableCapability(is.read_message()?));
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.errno != 0 {
            my_size += ::protobuf::rt::sint32_size(1, self.errno);
        }
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &vcpu_response::Message::Wait(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::GetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::SetState(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::GetMsrs(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::SetMsrs(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::SetCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::GetHypervCpuid(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
                &vcpu_response::Message::EnableCapability(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.errno != 0 {
            os.write_sint32(1, self.errno)?;
        }
        if let ::std::option::Option::Some(ref v) = self.message {
            match v {
                &vcpu_response::Message::Wait(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                },
                &vcpu_response::Message::GetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                },
                &vcpu_response::Message::SetState(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                },
                &vcpu_response::Message::GetMsrs(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
                },
                &vcpu_response::Message::SetMsrs(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
                },
                &vcpu_response::Message::SetCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
                },
                &vcpu_response::Message::GetHypervCpuid(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
                },
                &vcpu_response::Message::EnableCapability(ref v) => {
                    ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
                },
            };
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

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

    fn clear(&mut self) {
        self.errno = 0;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.message = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static VcpuResponse {
        static instance: VcpuResponse = VcpuResponse {
            errno: 0,
            message: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for VcpuResponse {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("VcpuResponse").unwrap()).clone()
    }
}

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

impl ::protobuf::reflect::ProtobufValue for VcpuResponse {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

/// Nested message and enums of message `VcpuResponse`
pub mod vcpu_response {

    #[derive(Clone,PartialEq,Debug)]
    #[non_exhaustive]
    // @@protoc_insertion_point(oneof:VcpuResponse.message)
    pub enum Message {
        // @@protoc_insertion_point(oneof_field:VcpuResponse.wait)
        Wait(Wait),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.get_state)
        GetState(GetState),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.set_state)
        SetState(SetState),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.get_msrs)
        GetMsrs(GetMsrs),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.set_msrs)
        SetMsrs(SetMsrs),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.set_cpuid)
        SetCpuid(SetCpuid),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.get_hyperv_cpuid)
        GetHypervCpuid(CpuidResponse),
        // @@protoc_insertion_point(oneof_field:VcpuResponse.enable_capability)
        EnableCapability(EnableCapability),
    }

    impl ::protobuf::Oneof for Message {
    }

    impl ::protobuf::OneofFull for Message {
        fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| <super::VcpuResponse as ::protobuf::MessageFull>::descriptor().oneof_by_name("message").unwrap()).clone()
        }
    }

    impl Message {
        pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
            ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Message>("message")
        }
    }
    // @@protoc_insertion_point(message:VcpuResponse.Wait)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct Wait {
        // message oneof groups
        pub exit: ::std::option::Option<wait::Exit>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.Wait.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        // .VcpuResponse.Wait.Init init = 1;

        pub fn init(&self) -> &wait::Init {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::Init(ref v)) => v,
                _ => <wait::Init as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_init(&mut self) {
            self.exit = ::std::option::Option::None;
        }

        pub fn has_init(&self) -> bool {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::Init(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_init(&mut self, v: wait::Init) {
            self.exit = ::std::option::Option::Some(wait::Exit::Init(v))
        }

        // Mutable pointer to the field.
        pub fn mut_init(&mut self) -> &mut wait::Init {
            if let ::std::option::Option::Some(wait::Exit::Init(_)) = self.exit {
            } else {
                self.exit = ::std::option::Option::Some(wait::Exit::Init(wait::Init::new()));
            }
            match self.exit {
                ::std::option::Option::Some(wait::Exit::Init(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_init(&mut self) -> wait::Init {
            if self.has_init() {
                match self.exit.take() {
                    ::std::option::Option::Some(wait::Exit::Init(v)) => v,
                    _ => panic!(),
                }
            } else {
                wait::Init::new()
            }
        }

        // .VcpuResponse.Wait.Io io = 2;

        pub fn io(&self) -> &wait::Io {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::Io(ref v)) => v,
                _ => <wait::Io as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_io(&mut self) {
            self.exit = ::std::option::Option::None;
        }

        pub fn has_io(&self) -> bool {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::Io(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_io(&mut self, v: wait::Io) {
            self.exit = ::std::option::Option::Some(wait::Exit::Io(v))
        }

        // Mutable pointer to the field.
        pub fn mut_io(&mut self) -> &mut wait::Io {
            if let ::std::option::Option::Some(wait::Exit::Io(_)) = self.exit {
            } else {
                self.exit = ::std::option::Option::Some(wait::Exit::Io(wait::Io::new()));
            }
            match self.exit {
                ::std::option::Option::Some(wait::Exit::Io(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_io(&mut self) -> wait::Io {
            if self.has_io() {
                match self.exit.take() {
                    ::std::option::Option::Some(wait::Exit::Io(v)) => v,
                    _ => panic!(),
                }
            } else {
                wait::Io::new()
            }
        }

        // .VcpuResponse.Wait.User user = 3;

        pub fn user(&self) -> &wait::User {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::User(ref v)) => v,
                _ => <wait::User as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_user(&mut self) {
            self.exit = ::std::option::Option::None;
        }

        pub fn has_user(&self) -> bool {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::User(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_user(&mut self, v: wait::User) {
            self.exit = ::std::option::Option::Some(wait::Exit::User(v))
        }

        // Mutable pointer to the field.
        pub fn mut_user(&mut self) -> &mut wait::User {
            if let ::std::option::Option::Some(wait::Exit::User(_)) = self.exit {
            } else {
                self.exit = ::std::option::Option::Some(wait::Exit::User(wait::User::new()));
            }
            match self.exit {
                ::std::option::Option::Some(wait::Exit::User(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_user(&mut self) -> wait::User {
            if self.has_user() {
                match self.exit.take() {
                    ::std::option::Option::Some(wait::Exit::User(v)) => v,
                    _ => panic!(),
                }
            } else {
                wait::User::new()
            }
        }

        // .VcpuResponse.Wait.HypervCall hyperv_call = 4;

        pub fn hyperv_call(&self) -> &wait::HypervCall {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::HypervCall(ref v)) => v,
                _ => <wait::HypervCall as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_hyperv_call(&mut self) {
            self.exit = ::std::option::Option::None;
        }

        pub fn has_hyperv_call(&self) -> bool {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::HypervCall(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_hyperv_call(&mut self, v: wait::HypervCall) {
            self.exit = ::std::option::Option::Some(wait::Exit::HypervCall(v))
        }

        // Mutable pointer to the field.
        pub fn mut_hyperv_call(&mut self) -> &mut wait::HypervCall {
            if let ::std::option::Option::Some(wait::Exit::HypervCall(_)) = self.exit {
            } else {
                self.exit = ::std::option::Option::Some(wait::Exit::HypervCall(wait::HypervCall::new()));
            }
            match self.exit {
                ::std::option::Option::Some(wait::Exit::HypervCall(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_hyperv_call(&mut self) -> wait::HypervCall {
            if self.has_hyperv_call() {
                match self.exit.take() {
                    ::std::option::Option::Some(wait::Exit::HypervCall(v)) => v,
                    _ => panic!(),
                }
            } else {
                wait::HypervCall::new()
            }
        }

        // .VcpuResponse.Wait.HypervSynic hyperv_synic = 5;

        pub fn hyperv_synic(&self) -> &wait::HypervSynic {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::HypervSynic(ref v)) => v,
                _ => <wait::HypervSynic as ::protobuf::Message>::default_instance(),
            }
        }

        pub fn clear_hyperv_synic(&mut self) {
            self.exit = ::std::option::Option::None;
        }

        pub fn has_hyperv_synic(&self) -> bool {
            match self.exit {
                ::std::option::Option::Some(wait::Exit::HypervSynic(..)) => true,
                _ => false,
            }
        }

        // Param is passed by value, moved
        pub fn set_hyperv_synic(&mut self, v: wait::HypervSynic) {
            self.exit = ::std::option::Option::Some(wait::Exit::HypervSynic(v))
        }

        // Mutable pointer to the field.
        pub fn mut_hyperv_synic(&mut self) -> &mut wait::HypervSynic {
            if let ::std::option::Option::Some(wait::Exit::HypervSynic(_)) = self.exit {
            } else {
                self.exit = ::std::option::Option::Some(wait::Exit::HypervSynic(wait::HypervSynic::new()));
            }
            match self.exit {
                ::std::option::Option::Some(wait::Exit::HypervSynic(ref mut v)) => v,
                _ => panic!(),
            }
        }

        // Take field
        pub fn take_hyperv_synic(&mut self) -> wait::HypervSynic {
            if self.has_hyperv_synic() {
                match self.exit.take() {
                    ::std::option::Option::Some(wait::Exit::HypervSynic(v)) => v,
                    _ => panic!(),
                }
            } else {
                wait::HypervSynic::new()
            }
        }

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(5);
            let mut oneofs = ::std::vec::Vec::with_capacity(1);
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, wait::Init>(
                "init",
                Wait::has_init,
                Wait::init,
                Wait::mut_init,
                Wait::set_init,
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, wait::Io>(
                "io",
                Wait::has_io,
                Wait::io,
                Wait::mut_io,
                Wait::set_io,
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, wait::User>(
                "user",
                Wait::has_user,
                Wait::user,
                Wait::mut_user,
                Wait::set_user,
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, wait::HypervCall>(
                "hyperv_call",
                Wait::has_hyperv_call,
                Wait::hyperv_call,
                Wait::mut_hyperv_call,
                Wait::set_hyperv_call,
            ));
            fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, wait::HypervSynic>(
                "hyperv_synic",
                Wait::has_hyperv_synic,
                Wait::hyperv_synic,
                Wait::mut_hyperv_synic,
                Wait::set_hyperv_synic,
            ));
            oneofs.push(wait::Exit::generated_oneof_descriptor_data());
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Wait>(
                "VcpuResponse.Wait",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for Wait {
        const NAME: &'static str = "Wait";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.exit = ::std::option::Option::Some(wait::Exit::Init(is.read_message()?));
                    },
                    18 => {
                        self.exit = ::std::option::Option::Some(wait::Exit::Io(is.read_message()?));
                    },
                    26 => {
                        self.exit = ::std::option::Option::Some(wait::Exit::User(is.read_message()?));
                    },
                    34 => {
                        self.exit = ::std::option::Option::Some(wait::Exit::HypervCall(is.read_message()?));
                    },
                    42 => {
                        self.exit = ::std::option::Option::Some(wait::Exit::HypervSynic(is.read_message()?));
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if let ::std::option::Option::Some(ref v) = self.exit {
                match v {
                    &wait::Exit::Init(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &wait::Exit::Io(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &wait::Exit::User(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &wait::Exit::HypervCall(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                    &wait::Exit::HypervSynic(ref v) => {
                        let len = v.compute_size();
                        my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
                    },
                };
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if let ::std::option::Option::Some(ref v) = self.exit {
                match v {
                    &wait::Exit::Init(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
                    },
                    &wait::Exit::Io(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
                    },
                    &wait::Exit::User(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
                    },
                    &wait::Exit::HypervCall(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
                    },
                    &wait::Exit::HypervSynic(ref v) => {
                        ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
                    },
                };
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.exit = ::std::option::Option::None;
            self.exit = ::std::option::Option::None;
            self.exit = ::std::option::Option::None;
            self.exit = ::std::option::Option::None;
            self.exit = ::std::option::Option::None;
            self.special_fields.clear();
        }

        fn default_instance() -> &'static Wait {
            static instance: Wait = Wait {
                exit: ::std::option::Option::None,
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for Wait {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.Wait").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for Wait {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    /// Nested message and enums of message `Wait`
    pub mod wait {

        #[derive(Clone,PartialEq,Debug)]
        #[non_exhaustive]
        // @@protoc_insertion_point(oneof:VcpuResponse.Wait.exit)
        pub enum Exit {
            // @@protoc_insertion_point(oneof_field:VcpuResponse.Wait.init)
            Init(Init),
            // @@protoc_insertion_point(oneof_field:VcpuResponse.Wait.io)
            Io(Io),
            // @@protoc_insertion_point(oneof_field:VcpuResponse.Wait.user)
            User(User),
            // @@protoc_insertion_point(oneof_field:VcpuResponse.Wait.hyperv_call)
            HypervCall(HypervCall),
            // @@protoc_insertion_point(oneof_field:VcpuResponse.Wait.hyperv_synic)
            HypervSynic(HypervSynic),
        }

        impl ::protobuf::Oneof for Exit {
        }

        impl ::protobuf::OneofFull for Exit {
            fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| <super::Wait as ::protobuf::MessageFull>::descriptor().oneof_by_name("exit").unwrap()).clone()
            }
        }

        impl Exit {
            pub(in super::super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
                ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Exit>("exit")
            }
        }
        // @@protoc_insertion_point(message:VcpuResponse.Wait.Init)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Init {
            // special fields
            // @@protoc_insertion_point(special_field:VcpuResponse.Wait.Init.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(0);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Init>(
                    "VcpuResponse.Wait.Init",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for Init {
            const NAME: &'static str = "Init";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

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

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

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Init {
                static instance: Init = Init {
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for Init {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("VcpuResponse.Wait.Init").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for Init {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        // @@protoc_insertion_point(message:VcpuResponse.Wait.Io)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct Io {
            // message fields
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.space)
            pub space: ::protobuf::EnumOrUnknown<super::super::AddressSpace>,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.address)
            pub address: u64,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.is_write)
            pub is_write: bool,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.no_resume)
            pub no_resume: bool,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.data)
            pub data: ::std::vec::Vec<u8>,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.regs)
            pub regs: ::std::vec::Vec<u8>,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.sregs)
            pub sregs: ::std::vec::Vec<u8>,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.Io.debugregs)
            pub debugregs: ::std::vec::Vec<u8>,
            // special fields
            // @@protoc_insertion_point(special_field:VcpuResponse.Wait.Io.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(8);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "space",
                    |m: &Io| { &m.space },
                    |m: &mut Io| { &mut m.space },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "address",
                    |m: &Io| { &m.address },
                    |m: &mut Io| { &mut m.address },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "is_write",
                    |m: &Io| { &m.is_write },
                    |m: &mut Io| { &mut m.is_write },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "no_resume",
                    |m: &Io| { &m.no_resume },
                    |m: &mut Io| { &mut m.no_resume },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "data",
                    |m: &Io| { &m.data },
                    |m: &mut Io| { &mut m.data },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "regs",
                    |m: &Io| { &m.regs },
                    |m: &mut Io| { &mut m.regs },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "sregs",
                    |m: &Io| { &m.sregs },
                    |m: &mut Io| { &mut m.sregs },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "debugregs",
                    |m: &Io| { &m.debugregs },
                    |m: &mut Io| { &mut m.debugregs },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Io>(
                    "VcpuResponse.Wait.Io",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for Io {
            const NAME: &'static str = "Io";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.space = is.read_enum_or_unknown()?;
                        },
                        16 => {
                            self.address = is.read_uint64()?;
                        },
                        24 => {
                            self.is_write = is.read_bool()?;
                        },
                        32 => {
                            self.no_resume = is.read_bool()?;
                        },
                        42 => {
                            self.data = is.read_bytes()?;
                        },
                        50 => {
                            self.regs = is.read_bytes()?;
                        },
                        58 => {
                            self.sregs = is.read_bytes()?;
                        },
                        66 => {
                            self.debugregs = is.read_bytes()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.space != ::protobuf::EnumOrUnknown::new(super::super::AddressSpace::IOPORT) {
                    my_size += ::protobuf::rt::int32_size(1, self.space.value());
                }
                if self.address != 0 {
                    my_size += ::protobuf::rt::uint64_size(2, self.address);
                }
                if self.is_write != false {
                    my_size += 1 + 1;
                }
                if self.no_resume != false {
                    my_size += 1 + 1;
                }
                if !self.data.is_empty() {
                    my_size += ::protobuf::rt::bytes_size(5, &self.data);
                }
                if !self.regs.is_empty() {
                    my_size += ::protobuf::rt::bytes_size(6, &self.regs);
                }
                if !self.sregs.is_empty() {
                    my_size += ::protobuf::rt::bytes_size(7, &self.sregs);
                }
                if !self.debugregs.is_empty() {
                    my_size += ::protobuf::rt::bytes_size(8, &self.debugregs);
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.space != ::protobuf::EnumOrUnknown::new(super::super::AddressSpace::IOPORT) {
                    os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.space))?;
                }
                if self.address != 0 {
                    os.write_uint64(2, self.address)?;
                }
                if self.is_write != false {
                    os.write_bool(3, self.is_write)?;
                }
                if self.no_resume != false {
                    os.write_bool(4, self.no_resume)?;
                }
                if !self.data.is_empty() {
                    os.write_bytes(5, &self.data)?;
                }
                if !self.regs.is_empty() {
                    os.write_bytes(6, &self.regs)?;
                }
                if !self.sregs.is_empty() {
                    os.write_bytes(7, &self.sregs)?;
                }
                if !self.debugregs.is_empty() {
                    os.write_bytes(8, &self.debugregs)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.space = ::protobuf::EnumOrUnknown::new(super::super::AddressSpace::IOPORT);
                self.address = 0;
                self.is_write = false;
                self.no_resume = false;
                self.data.clear();
                self.regs.clear();
                self.sregs.clear();
                self.debugregs.clear();
                self.special_fields.clear();
            }

            fn default_instance() -> &'static Io {
                static instance: Io = Io {
                    space: ::protobuf::EnumOrUnknown::from_i32(0),
                    address: 0,
                    is_write: false,
                    no_resume: false,
                    data: ::std::vec::Vec::new(),
                    regs: ::std::vec::Vec::new(),
                    sregs: ::std::vec::Vec::new(),
                    debugregs: ::std::vec::Vec::new(),
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for Io {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("VcpuResponse.Wait.Io").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for Io {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        // @@protoc_insertion_point(message:VcpuResponse.Wait.User)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct User {
            // message fields
            // @@protoc_insertion_point(field:VcpuResponse.Wait.User.user)
            pub user: u64,
            // special fields
            // @@protoc_insertion_point(special_field:VcpuResponse.Wait.User.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(1);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "user",
                    |m: &User| { &m.user },
                    |m: &mut User| { &mut m.user },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<User>(
                    "VcpuResponse.Wait.User",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for User {
            const NAME: &'static str = "User";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.user = is.read_uint64()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.user != 0 {
                    my_size += ::protobuf::rt::uint64_size(1, self.user);
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.user != 0 {
                    os.write_uint64(1, self.user)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.user = 0;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static User {
                static instance: User = User {
                    user: 0,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for User {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("VcpuResponse.Wait.User").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for User {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        // @@protoc_insertion_point(message:VcpuResponse.Wait.HypervCall)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct HypervCall {
            // message fields
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervCall.input)
            pub input: u64,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervCall.params0)
            pub params0: u64,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervCall.params1)
            pub params1: u64,
            // special fields
            // @@protoc_insertion_point(special_field:VcpuResponse.Wait.HypervCall.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(3);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "input",
                    |m: &HypervCall| { &m.input },
                    |m: &mut HypervCall| { &mut m.input },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "params0",
                    |m: &HypervCall| { &m.params0 },
                    |m: &mut HypervCall| { &mut m.params0 },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "params1",
                    |m: &HypervCall| { &m.params1 },
                    |m: &mut HypervCall| { &mut m.params1 },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HypervCall>(
                    "VcpuResponse.Wait.HypervCall",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for HypervCall {
            const NAME: &'static str = "HypervCall";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.input = is.read_uint64()?;
                        },
                        16 => {
                            self.params0 = is.read_uint64()?;
                        },
                        24 => {
                            self.params1 = is.read_uint64()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.input != 0 {
                    my_size += ::protobuf::rt::uint64_size(1, self.input);
                }
                if self.params0 != 0 {
                    my_size += ::protobuf::rt::uint64_size(2, self.params0);
                }
                if self.params1 != 0 {
                    my_size += ::protobuf::rt::uint64_size(3, self.params1);
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.input != 0 {
                    os.write_uint64(1, self.input)?;
                }
                if self.params0 != 0 {
                    os.write_uint64(2, self.params0)?;
                }
                if self.params1 != 0 {
                    os.write_uint64(3, self.params1)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.input = 0;
                self.params0 = 0;
                self.params1 = 0;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static HypervCall {
                static instance: HypervCall = HypervCall {
                    input: 0,
                    params0: 0,
                    params1: 0,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for HypervCall {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("VcpuResponse.Wait.HypervCall").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for HypervCall {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }

        // @@protoc_insertion_point(message:VcpuResponse.Wait.HypervSynic)
        #[derive(PartialEq,Clone,Default,Debug)]
        pub struct HypervSynic {
            // message fields
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervSynic.msr)
            pub msr: u32,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervSynic.control)
            pub control: u64,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervSynic.evt_page)
            pub evt_page: u64,
            // @@protoc_insertion_point(field:VcpuResponse.Wait.HypervSynic.msg_page)
            pub msg_page: u64,
            // special fields
            // @@protoc_insertion_point(special_field:VcpuResponse.Wait.HypervSynic.special_fields)
            pub special_fields: ::protobuf::SpecialFields,
        }

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

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

            pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
                let mut fields = ::std::vec::Vec::with_capacity(4);
                let mut oneofs = ::std::vec::Vec::with_capacity(0);
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "msr",
                    |m: &HypervSynic| { &m.msr },
                    |m: &mut HypervSynic| { &mut m.msr },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "control",
                    |m: &HypervSynic| { &m.control },
                    |m: &mut HypervSynic| { &mut m.control },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "evt_page",
                    |m: &HypervSynic| { &m.evt_page },
                    |m: &mut HypervSynic| { &mut m.evt_page },
                ));
                fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                    "msg_page",
                    |m: &HypervSynic| { &m.msg_page },
                    |m: &mut HypervSynic| { &mut m.msg_page },
                ));
                ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HypervSynic>(
                    "VcpuResponse.Wait.HypervSynic",
                    fields,
                    oneofs,
                )
            }
        }

        impl ::protobuf::Message for HypervSynic {
            const NAME: &'static str = "HypervSynic";

            fn is_initialized(&self) -> bool {
                true
            }

            fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
                while let Some(tag) = is.read_raw_tag_or_eof()? {
                    match tag {
                        8 => {
                            self.msr = is.read_uint32()?;
                        },
                        16 => {
                            self.control = is.read_uint64()?;
                        },
                        24 => {
                            self.evt_page = is.read_uint64()?;
                        },
                        32 => {
                            self.msg_page = is.read_uint64()?;
                        },
                        tag => {
                            ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                        },
                    };
                }
                ::std::result::Result::Ok(())
            }

            // Compute sizes of nested messages
            #[allow(unused_variables)]
            fn compute_size(&self) -> u64 {
                let mut my_size = 0;
                if self.msr != 0 {
                    my_size += ::protobuf::rt::uint32_size(1, self.msr);
                }
                if self.control != 0 {
                    my_size += ::protobuf::rt::uint64_size(2, self.control);
                }
                if self.evt_page != 0 {
                    my_size += ::protobuf::rt::uint64_size(3, self.evt_page);
                }
                if self.msg_page != 0 {
                    my_size += ::protobuf::rt::uint64_size(4, self.msg_page);
                }
                my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
                self.special_fields.cached_size().set(my_size as u32);
                my_size
            }

            fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
                if self.msr != 0 {
                    os.write_uint32(1, self.msr)?;
                }
                if self.control != 0 {
                    os.write_uint64(2, self.control)?;
                }
                if self.evt_page != 0 {
                    os.write_uint64(3, self.evt_page)?;
                }
                if self.msg_page != 0 {
                    os.write_uint64(4, self.msg_page)?;
                }
                os.write_unknown_fields(self.special_fields.unknown_fields())?;
                ::std::result::Result::Ok(())
            }

            fn special_fields(&self) -> &::protobuf::SpecialFields {
                &self.special_fields
            }

            fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
                &mut self.special_fields
            }

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

            fn clear(&mut self) {
                self.msr = 0;
                self.control = 0;
                self.evt_page = 0;
                self.msg_page = 0;
                self.special_fields.clear();
            }

            fn default_instance() -> &'static HypervSynic {
                static instance: HypervSynic = HypervSynic {
                    msr: 0,
                    control: 0,
                    evt_page: 0,
                    msg_page: 0,
                    special_fields: ::protobuf::SpecialFields::new(),
                };
                &instance
            }
        }

        impl ::protobuf::MessageFull for HypervSynic {
            fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
                static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
                descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("VcpuResponse.Wait.HypervSynic").unwrap()).clone()
            }
        }

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

        impl ::protobuf::reflect::ProtobufValue for HypervSynic {
            type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
        }
    }

    // @@protoc_insertion_point(message:VcpuResponse.GetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetState {
        // message fields
        // @@protoc_insertion_point(field:VcpuResponse.GetState.state)
        pub state: ::std::vec::Vec<u8>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.GetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
                "state",
                |m: &GetState| { &m.state },
                |m: &mut GetState| { &mut m.state },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetState>(
                "VcpuResponse.GetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetState {
        const NAME: &'static str = "GetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.state = is.read_bytes()?;
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            if !self.state.is_empty() {
                my_size += ::protobuf::rt::bytes_size(1, &self.state);
            }
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            if !self.state.is_empty() {
                os.write_bytes(1, &self.state)?;
            }
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.state.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetState {
            static instance: GetState = GetState {
                state: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.GetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuResponse.SetState)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetState {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.SetState.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetState>(
                "VcpuResponse.SetState",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetState {
        const NAME: &'static str = "SetState";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetState {
            static instance: SetState = SetState {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetState {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.SetState").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetState {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuResponse.CpuidResponse)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct CpuidResponse {
        // message fields
        // @@protoc_insertion_point(field:VcpuResponse.CpuidResponse.entries)
        pub entries: ::std::vec::Vec<super::CpuidEntry>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.CpuidResponse.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "entries",
                |m: &CpuidResponse| { &m.entries },
                |m: &mut CpuidResponse| { &mut m.entries },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CpuidResponse>(
                "VcpuResponse.CpuidResponse",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for CpuidResponse {
        const NAME: &'static str = "CpuidResponse";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        self.entries.push(is.read_message()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

        // Compute sizes of nested messages
        #[allow(unused_variables)]
        fn compute_size(&self) -> u64 {
            let mut my_size = 0;
            for value in &self.entries {
                let len = value.compute_size();
                my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
            };
            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
            self.special_fields.cached_size().set(my_size as u32);
            my_size
        }

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            for v in &self.entries {
                ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
            };
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.entries.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static CpuidResponse {
            static instance: CpuidResponse = CpuidResponse {
                entries: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for CpuidResponse {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.CpuidResponse").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for CpuidResponse {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuResponse.GetMsrs)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct GetMsrs {
        // message fields
        // @@protoc_insertion_point(field:VcpuResponse.GetMsrs.entry_data)
        pub entry_data: ::std::vec::Vec<u64>,
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.GetMsrs.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(1);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
                "entry_data",
                |m: &GetMsrs| { &m.entry_data },
                |m: &mut GetMsrs| { &mut m.entry_data },
            ));
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetMsrs>(
                "VcpuResponse.GetMsrs",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for GetMsrs {
        const NAME: &'static str = "GetMsrs";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    10 => {
                        is.read_repeated_packed_uint64_into(&mut self.entry_data)?;
                    },
                    8 => {
                        self.entry_data.push(is.read_uint64()?);
                    },
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
            os.write_repeated_packed_uint64(1, &self.entry_data)?;
            os.write_unknown_fields(self.special_fields.unknown_fields())?;
            ::std::result::Result::Ok(())
        }

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.entry_data.clear();
            self.special_fields.clear();
        }

        fn default_instance() -> &'static GetMsrs {
            static instance: GetMsrs = GetMsrs {
                entry_data: ::std::vec::Vec::new(),
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for GetMsrs {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.GetMsrs").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for GetMsrs {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuResponse.SetMsrs)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetMsrs {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.SetMsrs.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetMsrs>(
                "VcpuResponse.SetMsrs",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetMsrs {
        const NAME: &'static str = "SetMsrs";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetMsrs {
            static instance: SetMsrs = SetMsrs {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetMsrs {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.SetMsrs").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetMsrs {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuResponse.SetCpuid)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct SetCpuid {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.SetCpuid.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetCpuid>(
                "VcpuResponse.SetCpuid",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for SetCpuid {
        const NAME: &'static str = "SetCpuid";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static SetCpuid {
            static instance: SetCpuid = SetCpuid {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for SetCpuid {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.SetCpuid").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for SetCpuid {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }

    // @@protoc_insertion_point(message:VcpuResponse.EnableCapability)
    #[derive(PartialEq,Clone,Default,Debug)]
    pub struct EnableCapability {
        // special fields
        // @@protoc_insertion_point(special_field:VcpuResponse.EnableCapability.special_fields)
        pub special_fields: ::protobuf::SpecialFields,
    }

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

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

        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
            let mut fields = ::std::vec::Vec::with_capacity(0);
            let mut oneofs = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnableCapability>(
                "VcpuResponse.EnableCapability",
                fields,
                oneofs,
            )
        }
    }

    impl ::protobuf::Message for EnableCapability {
        const NAME: &'static str = "EnableCapability";

        fn is_initialized(&self) -> bool {
            true
        }

        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
            while let Some(tag) = is.read_raw_tag_or_eof()? {
                match tag {
                    tag => {
                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                    },
                };
            }
            ::std::result::Result::Ok(())
        }

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

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

        fn special_fields(&self) -> &::protobuf::SpecialFields {
            &self.special_fields
        }

        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
            &mut self.special_fields
        }

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

        fn clear(&mut self) {
            self.special_fields.clear();
        }

        fn default_instance() -> &'static EnableCapability {
            static instance: EnableCapability = EnableCapability {
                special_fields: ::protobuf::SpecialFields::new(),
            };
            &instance
        }
    }

    impl ::protobuf::MessageFull for EnableCapability {
        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("VcpuResponse.EnableCapability").unwrap()).clone()
        }
    }

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

    impl ::protobuf::reflect::ProtobufValue for EnableCapability {
        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:AddressSpace)
pub enum AddressSpace {
    // @@protoc_insertion_point(enum_value:AddressSpace.IOPORT)
    IOPORT = 0,
    // @@protoc_insertion_point(enum_value:AddressSpace.MMIO)
    MMIO = 1,
}

impl ::protobuf::Enum for AddressSpace {
    const NAME: &'static str = "AddressSpace";

    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<AddressSpace> {
        match value {
            0 => ::std::option::Option::Some(AddressSpace::IOPORT),
            1 => ::std::option::Option::Some(AddressSpace::MMIO),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<AddressSpace> {
        match str {
            "IOPORT" => ::std::option::Option::Some(AddressSpace::IOPORT),
            "MMIO" => ::std::option::Option::Some(AddressSpace::MMIO),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [AddressSpace] = &[
        AddressSpace::IOPORT,
        AddressSpace::MMIO,
    ];
}

impl ::protobuf::EnumFull for AddressSpace {
    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().enum_by_package_relative_name("AddressSpace").unwrap()).clone()
    }

    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
        let index = *self as usize;
        Self::enum_descriptor().value_by_index(index)
    }
}

impl ::std::default::Default for AddressSpace {
    fn default() -> Self {
        AddressSpace::IOPORT
    }
}

impl AddressSpace {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<AddressSpace>("AddressSpace")
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x0cplugin.proto\"\xa3\x01\n\nCpuidEntry\x12\x1a\n\x08function\x18\x01\
    \x20\x01(\rR\x08function\x12\x1b\n\thas_index\x18\x03\x20\x01(\x08R\x08h\
    asIndex\x12\x14\n\x05index\x18\x04\x20\x01(\rR\x05index\x12\x10\n\x03eax\
    \x18\x05\x20\x01(\rR\x03eax\x12\x10\n\x03ebx\x18\x06\x20\x01(\rR\x03ebx\
    \x12\x10\n\x03ecx\x18\x07\x20\x01(\rR\x03ecx\x12\x10\n\x03edx\x18\x08\
    \x20\x01(\rR\x03edx\"\x8f\x1a\n\x0bMainRequest\x12-\n\x06create\x18\x01\
    \x20\x01(\x0b2\x13.MainRequest.CreateH\0R\x06create\x120\n\x07destroy\
    \x18\x02\x20\x01(\x0b2\x14.MainRequest.DestroyH\0R\x07destroy\x12C\n\x0e\
    new_connection\x18\x03\x20\x01(\x0b2\x1a.MainRequest.NewConnectionH\0R\r\
    newConnection\x12S\n\x14get_shutdown_eventfd\x18\x04\x20\x01(\x0b2\x1f.M\
    ainRequest.GetShutdownEventfdH\0R\x12getShutdownEventfd\x12F\n\x0fcheck_\
    extension\x18\x05\x20\x01(\x0b2\x1b.MainRequest.CheckExtensionH\0R\x0ech\
    eckExtension\x12K\n\x13get_supported_cpuid\x18\x06\x20\x01(\x0b2\x19.Mai\
    nRequest.CpuidRequestH\0R\x11getSupportedCpuid\x12I\n\x12get_emulated_cp\
    uid\x18\x07\x20\x01(\x0b2\x19.MainRequest.CpuidRequestH\0R\x10getEmulate\
    dCpuid\x12J\n\x12get_msr_index_list\x18\x08\x20\x01(\x0b2\x1b.MainReques\
    t.MsrListRequestH\0R\x0fgetMsrIndexList\x12A\n\x0eget_net_config\x18\t\
    \x20\x01(\x0b2\x19.MainRequest.GetNetConfigH\0R\x0cgetNetConfig\x12@\n\r\
    reserve_range\x18\n\x20\x01(\x0b2\x19.MainRequest.ReserveRangeH\0R\x0cre\
    serveRange\x12.\n\x07set_irq\x18\x0b\x20\x01(\x0b2\x13.MainRequest.SetIr\
    qH\0R\x06setIrq\x12D\n\x0fset_irq_routing\x18\x0c\x20\x01(\x0b2\x1a.Main\
    Request.SetIrqRoutingH\0R\rsetIrqRouting\x124\n\tget_state\x18\r\x20\x01\
    (\x0b2\x15.MainRequest.GetStateH\0R\x08getState\x124\n\tset_state\x18\
    \x0e\x20\x01(\x0b2\x15.MainRequest.SetStateH\0R\x08setState\x12T\n\x15se\
    t_identity_map_addr\x18\x0f\x20\x01(\x0b2\x1f.MainRequest.SetIdentityMap\
    AddrH\0R\x12setIdentityMapAddr\x12:\n\x0bpause_vcpus\x18\x10\x20\x01(\
    \x0b2\x17.MainRequest.PauseVcpusH\0R\npauseVcpus\x124\n\tget_vcpus\x18\
    \x11\x20\x01(\x0b2\x15.MainRequest.GetVcpusH\0R\x08getVcpus\x12*\n\x05st\
    art\x18\x12\x20\x01(\x0b2\x12.MainRequest.StartH\0R\x05start\x12>\n\rset\
    _call_hint\x18\x13\x20\x01(\x0b2\x18.MainRequest.SetCallHintH\0R\x0bsetC\
    allHint\x12:\n\tdirty_log\x18e\x20\x01(\x0b2\x1b.MainRequest.MemoryDirty\
    LogH\0R\x08dirtyLog\x1a\x9e\x04\n\x06Create\x12\x0e\n\x02id\x18\x01\x20\
    \x01(\rR\x02id\x128\n\x08io_event\x18\x02\x20\x01(\x0b2\x1b.MainRequest.\
    Create.IoEventH\0R\x07ioEvent\x124\n\x06memory\x18\x03\x20\x01(\x0b2\x1a\
    .MainRequest.Create.MemoryH\0R\x06memory\x12;\n\tirq_event\x18\x04\x20\
    \x01(\x0b2\x1c.MainRequest.Create.IrqEventH\0R\x08irqEvent\x1a~\n\x07IoE\
    vent\x12#\n\x05space\x18\x01\x20\x01(\x0e2\r.AddressSpaceR\x05space\x12\
    \x18\n\x07address\x18\x02\x20\x01(\x04R\x07address\x12\x16\n\x06length\
    \x18\x03\x20\x01(\rR\x06length\x12\x1c\n\tdatamatch\x18\x04\x20\x01(\x04\
    R\tdatamatch\x1a\x88\x01\n\x06Memory\x12\x16\n\x06offset\x18\x01\x20\x01\
    (\x04R\x06offset\x12\x14\n\x05start\x18\x02\x20\x01(\x04R\x05start\x12\
    \x16\n\x06length\x18\x03\x20\x01(\x04R\x06length\x12\x1b\n\tread_only\
    \x18\x04\x20\x01(\x08R\x08readOnly\x12\x1b\n\tdirty_log\x18\x05\x20\x01(\
    \x08R\x08dirtyLog\x1a=\n\x08IrqEvent\x12\x15\n\x06irq_id\x18\x01\x20\x01\
    (\rR\x05irqId\x12\x1a\n\x08resample\x18\x02\x20\x01(\x08R\x08resampleB\r\
    \n\x0bconstructor\x1a\x19\n\x07Destroy\x12\x0e\n\x02id\x18\x01\x20\x01(\
    \rR\x02id\x1a\x0f\n\rNewConnection\x1a\x14\n\x12GetShutdownEventfd\x1a.\
    \n\x0eCheckExtension\x12\x1c\n\textension\x18\x01\x20\x01(\rR\textension\
    \x1a\x0e\n\x0cCpuidRequest\x1a\x10\n\x0eMsrListRequest\x1a\x0e\n\x0cGetN\
    etConfig\x1a\x82\x01\n\x0cReserveRange\x12#\n\x05space\x18\x01\x20\x01(\
    \x0e2\r.AddressSpaceR\x05space\x12\x14\n\x05start\x18\x02\x20\x01(\x04R\
    \x05start\x12\x16\n\x06length\x18\x03\x20\x01(\x04R\x06length\x12\x1f\n\
    \x0basync_write\x18\x04\x20\x01(\x08R\nasyncWrite\x1a7\n\x06SetIrq\x12\
    \x15\n\x06irq_id\x18\x01\x20\x01(\rR\x05irqId\x12\x16\n\x06active\x18\
    \x02\x20\x01(\x08R\x06active\x1a\xdf\x02\n\rSetIrqRouting\x128\n\x06rout\
    es\x18\x01\x20\x03(\x0b2\x20.MainRequest.SetIrqRouting.RouteR\x06routes\
    \x1a\x93\x02\n\x05Route\x12\x15\n\x06irq_id\x18\x01\x20\x01(\rR\x05irqId\
    \x12D\n\x07irqchip\x18\x02\x20\x01(\x0b2(.MainRequest.SetIrqRouting.Rout\
    e.IrqchipH\0R\x07irqchip\x128\n\x03msi\x18\x03\x20\x01(\x0b2$.MainReques\
    t.SetIrqRouting.Route.MsiH\0R\x03msi\x1a5\n\x07Irqchip\x12\x18\n\x07irqc\
    hip\x18\x01\x20\x01(\rR\x07irqchip\x12\x10\n\x03pin\x18\x02\x20\x01(\rR\
    \x03pin\x1a3\n\x03Msi\x12\x18\n\x07address\x18\x01\x20\x01(\x04R\x07addr\
    ess\x12\x12\n\x04data\x18\x02\x20\x01(\rR\x04dataB\x07\n\x05route\x1a3\n\
    \x08GetState\x12'\n\x03set\x18\x01\x20\x01(\x0e2\x15.MainRequest.StateSe\
    tR\x03set\x1aI\n\x08SetState\x12'\n\x03set\x18\x01\x20\x01(\x0e2\x15.Mai\
    nRequest.StateSetR\x03set\x12\x14\n\x05state\x18\x02\x20\x01(\x0cR\x05st\
    ate\x1a.\n\x12SetIdentityMapAddr\x12\x18\n\x07address\x18\x01\x20\x01(\r\
    R\x07address\x1a;\n\nPauseVcpus\x12\x19\n\x08cpu_mask\x18\x01\x20\x01(\
    \x04R\x07cpuMask\x12\x12\n\x04user\x18\x02\x20\x01(\x04R\x04user\x1a\n\n\
    \x08GetVcpus\x1a\x07\n\x05Start\x1a\xad\x03\n\x0bSetCallHint\x12#\n\x05s\
    pace\x18\x01\x20\x01(\x0e2\r.AddressSpaceR\x05space\x12\x18\n\x07address\
    \x18\x02\x20\x01(\x04R\x07address\x12\x19\n\x08on_write\x18\x03\x20\x01(\
    \x08R\x07onWrite\x126\n\x05hints\x18\x04\x20\x03(\x0b2\x20.MainRequest.S\
    etCallHint.RegHintR\x05hints\x1a\x8b\x02\n\x07RegHint\x12\x1b\n\tmatch_r\
    ax\x18\x01\x20\x01(\x08R\x08matchRax\x12\x1b\n\tmatch_rbx\x18\x02\x20\
    \x01(\x08R\x08matchRbx\x12\x1b\n\tmatch_rcx\x18\x03\x20\x01(\x08R\x08mat\
    chRcx\x12\x1b\n\tmatch_rdx\x18\x04\x20\x01(\x08R\x08matchRdx\x12\x10\n\
    \x03rax\x18\x05\x20\x01(\x04R\x03rax\x12\x10\n\x03rbx\x18\x06\x20\x01(\
    \x04R\x03rbx\x12\x10\n\x03rcx\x18\x07\x20\x01(\x04R\x03rcx\x12\x10\n\x03\
    rdx\x18\x08\x20\x01(\x04R\x03rdx\x12\x1d\n\nsend_sregs\x18\t\x20\x01(\
    \x08R\tsendSregs\x12%\n\x0esend_debugregs\x18\n\x20\x01(\x08R\rsendDebug\
    regs\x1a\x20\n\x0eMemoryDirtyLog\x12\x0e\n\x02id\x18\x01\x20\x01(\rR\x02\
    id\">\n\x08StateSet\x12\x08\n\x04PIC0\x10\0\x12\x08\n\x04PIC1\x10\x01\
    \x12\n\n\x06IOAPIC\x10\x02\x12\x07\n\x03PIT\x10\x03\x12\t\n\x05CLOCK\x10\
    \x04B\t\n\x07message\"\xe7\x0e\n\x0cMainResponse\x12\x14\n\x05errno\x18\
    \x01\x20\x01(\x11R\x05errno\x12.\n\x06create\x18\x02\x20\x01(\x0b2\x14.M\
    ainResponse.CreateH\0R\x06create\x121\n\x07destroy\x18\x03\x20\x01(\x0b2\
    \x15.MainResponse.DestroyH\0R\x07destroy\x12D\n\x0enew_connection\x18\
    \x04\x20\x01(\x0b2\x1b.MainResponse.NewConnectionH\0R\rnewConnection\x12\
    T\n\x14get_shutdown_eventfd\x18\x05\x20\x01(\x0b2\x20.MainResponse.GetSh\
    utdownEventfdH\0R\x12getShutdownEventfd\x12G\n\x0fcheck_extension\x18\
    \x06\x20\x01(\x0b2\x1c.MainResponse.CheckExtensionH\0R\x0echeckExtension\
    \x12M\n\x13get_supported_cpuid\x18\x07\x20\x01(\x0b2\x1b.MainResponse.Cp\
    uidResponseH\0R\x11getSupportedCpuid\x12K\n\x12get_emulated_cpuid\x18\
    \x08\x20\x01(\x0b2\x1b.MainResponse.CpuidResponseH\0R\x10getEmulatedCpui\
    d\x12L\n\x12get_msr_index_list\x18\t\x20\x01(\x0b2\x1d.MainResponse.MsrL\
    istResponseH\0R\x0fgetMsrIndexList\x12B\n\x0eget_net_config\x18\n\x20\
    \x01(\x0b2\x1a.MainResponse.GetNetConfigH\0R\x0cgetNetConfig\x12A\n\rres\
    erve_range\x18\x0b\x20\x01(\x0b2\x1a.MainResponse.ReserveRangeH\0R\x0cre\
    serveRange\x12/\n\x07set_irq\x18\x0c\x20\x01(\x0b2\x14.MainResponse.SetI\
    rqH\0R\x06setIrq\x12E\n\x0fset_irq_routing\x18\r\x20\x01(\x0b2\x1b.MainR\
    esponse.SetIrqRoutingH\0R\rsetIrqRouting\x125\n\tget_state\x18\x0e\x20\
    \x01(\x0b2\x16.MainResponse.GetStateH\0R\x08getState\x125\n\tset_state\
    \x18\x0f\x20\x01(\x0b2\x16.MainResponse.SetStateH\0R\x08setState\x12U\n\
    \x15set_identity_map_addr\x18\x10\x20\x01(\x0b2\x20.MainResponse.SetIden\
    tityMapAddrH\0R\x12setIdentityMapAddr\x12;\n\x0bpause_vcpus\x18\x11\x20\
    \x01(\x0b2\x18.MainResponse.PauseVcpusH\0R\npauseVcpus\x125\n\tget_vcpus\
    \x18\x12\x20\x01(\x0b2\x16.MainResponse.GetVcpusH\0R\x08getVcpus\x12+\n\
    \x05start\x18\x13\x20\x01(\x0b2\x13.MainResponse.StartH\0R\x05start\x12?\
    \n\rset_call_hint\x18\x14\x20\x01(\x0b2\x19.MainResponse.SetCallHintH\0R\
    \x0bsetCallHint\x12;\n\tdirty_log\x18e\x20\x01(\x0b2\x1c.MainResponse.Me\
    moryDirtyLogH\0R\x08dirtyLog\x1a\x08\n\x06Create\x1a\t\n\x07Destroy\x1a\
    \x0f\n\rNewConnection\x1a\x14\n\x12GetShutdownEventfd\x1a5\n\x0eCheckExt\
    ension\x12#\n\rhas_extension\x18\x01\x20\x01(\x08R\x0chasExtension\x1a6\
    \n\rCpuidResponse\x12%\n\x07entries\x18\x01\x20\x03(\x0b2\x0b.CpuidEntry\
    R\x07entries\x1a+\n\x0fMsrListResponse\x12\x18\n\x07indices\x18\x01\x20\
    \x03(\rR\x07indices\x1a~\n\x0cGetNetConfig\x12(\n\x10host_mac_address\
    \x18\x01\x20\x01(\x0cR\x0ehostMacAddress\x12*\n\x11host_ipv4_address\x18\
    \x02\x20\x01(\x07R\x0fhostIpv4Address\x12\x18\n\x07netmask\x18\x03\x20\
    \x01(\x07R\x07netmask\x1a\x0e\n\x0cReserveRange\x1a\x08\n\x06SetIrq\x1a\
    \x0f\n\rSetIrqRouting\x1a\x20\n\x08GetState\x12\x14\n\x05state\x18\x01\
    \x20\x01(\x0cR\x05state\x1a\n\n\x08SetState\x1a\x14\n\x12SetIdentityMapA\
    ddr\x1a\x0c\n\nPauseVcpus\x1a\n\n\x08GetVcpus\x1a\x07\n\x05Start\x1a\r\n\
    \x0bSetCallHint\x1a(\n\x0eMemoryDirtyLog\x12\x16\n\x06bitmap\x18\x01\x20\
    \x01(\x0cR\x06bitmapB\t\n\x07message\"\xb9\t\n\x0bVcpuRequest\x12'\n\x04\
    wait\x18\x01\x20\x01(\x0b2\x11.VcpuRequest.WaitH\0R\x04wait\x12-\n\x06re\
    sume\x18\x02\x20\x01(\x0b2\x13.VcpuRequest.ResumeH\0R\x06resume\x124\n\t\
    get_state\x18\x03\x20\x01(\x0b2\x15.VcpuRequest.GetStateH\0R\x08getState\
    \x124\n\tset_state\x18\x04\x20\x01(\x0b2\x15.VcpuRequest.SetStateH\0R\
    \x08setState\x121\n\x08get_msrs\x18\x05\x20\x01(\x0b2\x14.VcpuRequest.Ge\
    tMsrsH\0R\x07getMsrs\x121\n\x08set_msrs\x18\x06\x20\x01(\x0b2\x14.VcpuRe\
    quest.SetMsrsH\0R\x07setMsrs\x124\n\tset_cpuid\x18\x07\x20\x01(\x0b2\x15\
    .VcpuRequest.SetCpuidH\0R\x08setCpuid\x123\n\x08shutdown\x18\x08\x20\x01\
    (\x0b2\x15.VcpuRequest.ShutdownH\0R\x08shutdown\x12E\n\x10get_hyperv_cpu\
    id\x18\t\x20\x01(\x0b2\x19.VcpuRequest.CpuidRequestH\0R\x0egetHypervCpui\
    d\x12L\n\x11enable_capability\x18\n\x20\x01(\x0b2\x1d.VcpuRequest.Enable\
    CapabilityH\0R\x10enableCapability\x1a\x06\n\x04Wait\x1ad\n\x06Resume\
    \x12\x12\n\x04data\x18\x01\x20\x01(\x0cR\x04data\x12\x12\n\x04regs\x18\
    \x02\x20\x01(\x0cR\x04regs\x12\x14\n\x05sregs\x18\x03\x20\x01(\x0cR\x05s\
    regs\x12\x1c\n\tdebugregs\x18\x04\x20\x01(\x0cR\tdebugregs\x1a3\n\x08Get\
    State\x12'\n\x03set\x18\x01\x20\x01(\x0e2\x15.VcpuRequest.StateSetR\x03s\
    et\x1aI\n\x08SetState\x12'\n\x03set\x18\x01\x20\x01(\x0e2\x15.VcpuReques\
    t.StateSetR\x03set\x12\x14\n\x05state\x18\x02\x20\x01(\x0cR\x05state\x1a\
    \x0e\n\x0cCpuidRequest\x1a.\n\x07GetMsrs\x12#\n\rentry_indices\x18\x01\
    \x20\x03(\rR\x0centryIndices\x1a4\n\x08MsrEntry\x12\x14\n\x05index\x18\
    \x01\x20\x01(\rR\x05index\x12\x12\n\x04data\x18\x02\x20\x01(\x04R\x04dat\
    a\x1a:\n\x07SetMsrs\x12/\n\x07entries\x18\x01\x20\x03(\x0b2\x15.VcpuRequ\
    est.MsrEntryR\x07entries\x1a1\n\x08SetCpuid\x12%\n\x07entries\x18\x01\
    \x20\x03(\x0b2\x0b.CpuidEntryR\x07entries\x1a\n\n\x08Shutdown\x1a2\n\x10\
    EnableCapability\x12\x1e\n\ncapability\x18\x01\x20\x01(\rR\ncapability\"\
    b\n\x08StateSet\x12\x08\n\x04REGS\x10\0\x12\t\n\x05SREGS\x10\x01\x12\x07\
    \n\x03FPU\x10\x02\x12\r\n\tDEBUGREGS\x10\x03\x12\t\n\x05LAPIC\x10\x04\
    \x12\x06\n\x02MP\x10\x05\x12\n\n\x06XCREGS\x10\x06\x12\n\n\x06EVENTS\x10\
    \x07B\t\n\x07message\"\x9f\x0b\n\x0cVcpuResponse\x12\x14\n\x05errno\x18\
    \x01\x20\x01(\x11R\x05errno\x12(\n\x04wait\x18\x02\x20\x01(\x0b2\x12.Vcp\
    uResponse.WaitH\0R\x04wait\x125\n\tget_state\x18\x04\x20\x01(\x0b2\x16.V\
    cpuResponse.GetStateH\0R\x08getState\x125\n\tset_state\x18\x05\x20\x01(\
    \x0b2\x16.VcpuResponse.SetStateH\0R\x08setState\x122\n\x08get_msrs\x18\
    \x06\x20\x01(\x0b2\x15.VcpuResponse.GetMsrsH\0R\x07getMsrs\x122\n\x08set\
    _msrs\x18\x07\x20\x01(\x0b2\x15.VcpuResponse.SetMsrsH\0R\x07setMsrs\x125\
    \n\tset_cpuid\x18\x08\x20\x01(\x0b2\x16.VcpuResponse.SetCpuidH\0R\x08set\
    Cpuid\x12G\n\x10get_hyperv_cpuid\x18\t\x20\x01(\x0b2\x1b.VcpuResponse.Cp\
    uidResponseH\0R\x0egetHypervCpuid\x12M\n\x11enable_capability\x18\n\x20\
    \x01(\x0b2\x1e.VcpuResponse.EnableCapabilityH\0R\x10enableCapability\x1a\
    \xe3\x05\n\x04Wait\x12-\n\x04init\x18\x01\x20\x01(\x0b2\x17.VcpuResponse\
    .Wait.InitH\0R\x04init\x12'\n\x02io\x18\x02\x20\x01(\x0b2\x15.VcpuRespon\
    se.Wait.IoH\0R\x02io\x12-\n\x04user\x18\x03\x20\x01(\x0b2\x17.VcpuRespon\
    se.Wait.UserH\0R\x04user\x12@\n\x0bhyperv_call\x18\x04\x20\x01(\x0b2\x1d\
    .VcpuResponse.Wait.HypervCallH\0R\nhypervCall\x12C\n\x0chyperv_synic\x18\
    \x05\x20\x01(\x0b2\x1e.VcpuResponse.Wait.HypervSynicH\0R\x0bhypervSynic\
    \x1a\x06\n\x04Init\x1a\xd7\x01\n\x02Io\x12#\n\x05space\x18\x01\x20\x01(\
    \x0e2\r.AddressSpaceR\x05space\x12\x18\n\x07address\x18\x02\x20\x01(\x04\
    R\x07address\x12\x19\n\x08is_write\x18\x03\x20\x01(\x08R\x07isWrite\x12\
    \x1b\n\tno_resume\x18\x04\x20\x01(\x08R\x08noResume\x12\x12\n\x04data\
    \x18\x05\x20\x01(\x0cR\x04data\x12\x12\n\x04regs\x18\x06\x20\x01(\x0cR\
    \x04regs\x12\x14\n\x05sregs\x18\x07\x20\x01(\x0cR\x05sregs\x12\x1c\n\tde\
    bugregs\x18\x08\x20\x01(\x0cR\tdebugregs\x1a\x1a\n\x04User\x12\x12\n\x04\
    user\x18\x01\x20\x01(\x04R\x04user\x1aV\n\nHypervCall\x12\x14\n\x05input\
    \x18\x01\x20\x01(\x04R\x05input\x12\x18\n\x07params0\x18\x02\x20\x01(\
    \x04R\x07params0\x12\x18\n\x07params1\x18\x03\x20\x01(\x04R\x07params1\
    \x1ao\n\x0bHypervSynic\x12\x10\n\x03msr\x18\x01\x20\x01(\rR\x03msr\x12\
    \x18\n\x07control\x18\x02\x20\x01(\x04R\x07control\x12\x19\n\x08evt_page\
    \x18\x03\x20\x01(\x04R\x07evtPage\x12\x19\n\x08msg_page\x18\x04\x20\x01(\
    \x04R\x07msgPageB\x06\n\x04exit\x1a\x20\n\x08GetState\x12\x14\n\x05state\
    \x18\x01\x20\x01(\x0cR\x05state\x1a\n\n\x08SetState\x1a6\n\rCpuidRespons\
    e\x12%\n\x07entries\x18\x01\x20\x03(\x0b2\x0b.CpuidEntryR\x07entries\x1a\
    (\n\x07GetMsrs\x12\x1d\n\nentry_data\x18\x01\x20\x03(\x04R\tentryData\
    \x1a\t\n\x07SetMsrs\x1a\n\n\x08SetCpuid\x1a\x12\n\x10EnableCapabilityB\t\
    \n\x07message*$\n\x0cAddressSpace\x12\n\n\x06IOPORT\x10\0\x12\x08\n\x04M\
    MIO\x10\x01b\x06proto3\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(0);
            let mut messages = ::std::vec::Vec::with_capacity(74);
            messages.push(CpuidEntry::generated_message_descriptor_data());
            messages.push(MainRequest::generated_message_descriptor_data());
            messages.push(MainResponse::generated_message_descriptor_data());
            messages.push(VcpuRequest::generated_message_descriptor_data());
            messages.push(VcpuResponse::generated_message_descriptor_data());
            messages.push(main_request::Create::generated_message_descriptor_data());
            messages.push(main_request::Destroy::generated_message_descriptor_data());
            messages.push(main_request::NewConnection::generated_message_descriptor_data());
            messages.push(main_request::GetShutdownEventfd::generated_message_descriptor_data());
            messages.push(main_request::CheckExtension::generated_message_descriptor_data());
            messages.push(main_request::CpuidRequest::generated_message_descriptor_data());
            messages.push(main_request::MsrListRequest::generated_message_descriptor_data());
            messages.push(main_request::GetNetConfig::generated_message_descriptor_data());
            messages.push(main_request::ReserveRange::generated_message_descriptor_data());
            messages.push(main_request::SetIrq::generated_message_descriptor_data());
            messages.push(main_request::SetIrqRouting::generated_message_descriptor_data());
            messages.push(main_request::GetState::generated_message_descriptor_data());
            messages.push(main_request::SetState::generated_message_descriptor_data());
            messages.push(main_request::SetIdentityMapAddr::generated_message_descriptor_data());
            messages.push(main_request::PauseVcpus::generated_message_descriptor_data());
            messages.push(main_request::GetVcpus::generated_message_descriptor_data());
            messages.push(main_request::Start::generated_message_descriptor_data());
            messages.push(main_request::SetCallHint::generated_message_descriptor_data());
            messages.push(main_request::MemoryDirtyLog::generated_message_descriptor_data());
            messages.push(main_request::create::IoEvent::generated_message_descriptor_data());
            messages.push(main_request::create::Memory::generated_message_descriptor_data());
            messages.push(main_request::create::IrqEvent::generated_message_descriptor_data());
            messages.push(main_request::set_irq_routing::Route::generated_message_descriptor_data());
            messages.push(main_request::set_irq_routing::route::Irqchip::generated_message_descriptor_data());
            messages.push(main_request::set_irq_routing::route::Msi::generated_message_descriptor_data());
            messages.push(main_request::set_call_hint::RegHint::generated_message_descriptor_data());
            messages.push(main_response::Create::generated_message_descriptor_data());
            messages.push(main_response::Destroy::generated_message_descriptor_data());
            messages.push(main_response::NewConnection::generated_message_descriptor_data());
            messages.push(main_response::GetShutdownEventfd::generated_message_descriptor_data());
            messages.push(main_response::CheckExtension::generated_message_descriptor_data());
            messages.push(main_response::CpuidResponse::generated_message_descriptor_data());
            messages.push(main_response::MsrListResponse::generated_message_descriptor_data());
            messages.push(main_response::GetNetConfig::generated_message_descriptor_data());
            messages.push(main_response::ReserveRange::generated_message_descriptor_data());
            messages.push(main_response::SetIrq::generated_message_descriptor_data());
            messages.push(main_response::SetIrqRouting::generated_message_descriptor_data());
            messages.push(main_response::GetState::generated_message_descriptor_data());
            messages.push(main_response::SetState::generated_message_descriptor_data());
            messages.push(main_response::SetIdentityMapAddr::generated_message_descriptor_data());
            messages.push(main_response::PauseVcpus::generated_message_descriptor_data());
            messages.push(main_response::GetVcpus::generated_message_descriptor_data());
            messages.push(main_response::Start::generated_message_descriptor_data());
            messages.push(main_response::SetCallHint::generated_message_descriptor_data());
            messages.push(main_response::MemoryDirtyLog::generated_message_descriptor_data());
            messages.push(vcpu_request::Wait::generated_message_descriptor_data());
            messages.push(vcpu_request::Resume::generated_message_descriptor_data());
            messages.push(vcpu_request::GetState::generated_message_descriptor_data());
            messages.push(vcpu_request::SetState::generated_message_descriptor_data());
            messages.push(vcpu_request::CpuidRequest::generated_message_descriptor_data());
            messages.push(vcpu_request::GetMsrs::generated_message_descriptor_data());
            messages.push(vcpu_request::MsrEntry::generated_message_descriptor_data());
            messages.push(vcpu_request::SetMsrs::generated_message_descriptor_data());
            messages.push(vcpu_request::SetCpuid::generated_message_descriptor_data());
            messages.push(vcpu_request::Shutdown::generated_message_descriptor_data());
            messages.push(vcpu_request::EnableCapability::generated_message_descriptor_data());
            messages.push(vcpu_response::Wait::generated_message_descriptor_data());
            messages.push(vcpu_response::GetState::generated_message_descriptor_data());
            messages.push(vcpu_response::SetState::generated_message_descriptor_data());
            messages.push(vcpu_response::CpuidResponse::generated_message_descriptor_data());
            messages.push(vcpu_response::GetMsrs::generated_message_descriptor_data());
            messages.push(vcpu_response::SetMsrs::generated_message_descriptor_data());
            messages.push(vcpu_response::SetCpuid::generated_message_descriptor_data());
            messages.push(vcpu_response::EnableCapability::generated_message_descriptor_data());
            messages.push(vcpu_response::wait::Init::generated_message_descriptor_data());
            messages.push(vcpu_response::wait::Io::generated_message_descriptor_data());
            messages.push(vcpu_response::wait::User::generated_message_descriptor_data());
            messages.push(vcpu_response::wait::HypervCall::generated_message_descriptor_data());
            messages.push(vcpu_response::wait::HypervSynic::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(3);
            enums.push(AddressSpace::generated_enum_descriptor_data());
            enums.push(main_request::StateSet::generated_enum_descriptor_data());
            enums.push(vcpu_request::StateSet::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}