// This file is generated by rust-protobuf 3.7.2. Do not edit
// .proto file is parsed by protoc 3.19.6
// @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 `rpc.proto`

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

// @@protoc_insertion_point(message:criu_page_server_info)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_page_server_info {
    // message fields
    // @@protoc_insertion_point(field:criu_page_server_info.address)
    pub address: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_page_server_info.port)
    pub port: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_page_server_info.pid)
    pub pid: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_page_server_info.fd)
    pub fd: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_page_server_info.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional string address = 1;

    pub fn address(&self) -> &str {
        match self.address.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_address(&self) -> bool {
        self.address.is_some()
    }

    // Param is passed by value, moved
    pub fn set_address(&mut self, v: ::std::string::String) {
        self.address = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address(&mut self) -> &mut ::std::string::String {
        if self.address.is_none() {
            self.address = ::std::option::Option::Some(::std::string::String::new());
        }
        self.address.as_mut().unwrap()
    }

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

    // optional int32 port = 2;

    pub fn port(&self) -> i32 {
        self.port.unwrap_or(0)
    }

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

    pub fn has_port(&self) -> bool {
        self.port.is_some()
    }

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

    // optional int32 pid = 3;

    pub fn pid(&self) -> i32 {
        self.pid.unwrap_or(0)
    }

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

    pub fn has_pid(&self) -> bool {
        self.pid.is_some()
    }

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

    // optional int32 fd = 4;

    pub fn fd(&self) -> i32 {
        self.fd.unwrap_or(0)
    }

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

    pub fn has_fd(&self) -> bool {
        self.fd.is_some()
    }

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

    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_option_accessor::<_, _>(
            "address",
            |m: &Criu_page_server_info| { &m.address },
            |m: &mut Criu_page_server_info| { &mut m.address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "port",
            |m: &Criu_page_server_info| { &m.port },
            |m: &mut Criu_page_server_info| { &mut m.port },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pid",
            |m: &Criu_page_server_info| { &m.pid },
            |m: &mut Criu_page_server_info| { &mut m.pid },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "fd",
            |m: &Criu_page_server_info| { &m.fd },
            |m: &mut Criu_page_server_info| { &mut m.fd },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_page_server_info>(
            "criu_page_server_info",
            fields,
            oneofs,
        )
    }
}

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

    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.address = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.port = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.pid = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.fd = ::std::option::Option::Some(is.read_int32()?);
                },
                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 Some(v) = self.address.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.port {
            my_size += ::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.pid {
            my_size += ::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.fd {
            my_size += ::protobuf::rt::int32_size(4, v);
        }
        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 Some(v) = self.address.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.port {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.pid {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.fd {
            os.write_int32(4, v)?;
        }
        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() -> Criu_page_server_info {
        Criu_page_server_info::new()
    }

    fn clear(&mut self) {
        self.address = ::std::option::Option::None;
        self.port = ::std::option::Option::None;
        self.pid = ::std::option::Option::None;
        self.fd = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Criu_page_server_info {
        static instance: Criu_page_server_info = Criu_page_server_info {
            address: ::std::option::Option::None,
            port: ::std::option::Option::None,
            pid: ::std::option::Option::None,
            fd: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Criu_page_server_info {
    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("criu_page_server_info").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_veth_pair)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_veth_pair {
    // message fields
    // @@protoc_insertion_point(field:criu_veth_pair.if_in)
    pub if_in: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_veth_pair.if_out)
    pub if_out: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_veth_pair.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required string if_in = 1;

    pub fn if_in(&self) -> &str {
        match self.if_in.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_if_in(&self) -> bool {
        self.if_in.is_some()
    }

    // Param is passed by value, moved
    pub fn set_if_in(&mut self, v: ::std::string::String) {
        self.if_in = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_if_in(&mut self) -> &mut ::std::string::String {
        if self.if_in.is_none() {
            self.if_in = ::std::option::Option::Some(::std::string::String::new());
        }
        self.if_in.as_mut().unwrap()
    }

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

    // required string if_out = 2;

    pub fn if_out(&self) -> &str {
        match self.if_out.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_if_out(&self) -> bool {
        self.if_out.is_some()
    }

    // Param is passed by value, moved
    pub fn set_if_out(&mut self, v: ::std::string::String) {
        self.if_out = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_if_out(&mut self) -> &mut ::std::string::String {
        if self.if_out.is_none() {
            self.if_out = ::std::option::Option::Some(::std::string::String::new());
        }
        self.if_out.as_mut().unwrap()
    }

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

    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_option_accessor::<_, _>(
            "if_in",
            |m: &Criu_veth_pair| { &m.if_in },
            |m: &mut Criu_veth_pair| { &mut m.if_in },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "if_out",
            |m: &Criu_veth_pair| { &m.if_out },
            |m: &mut Criu_veth_pair| { &mut m.if_out },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_veth_pair>(
            "criu_veth_pair",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.if_in.is_none() {
            return false;
        }
        if self.if_out.is_none() {
            return false;
        }
        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.if_in = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.if_out = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.if_in.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.if_out.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        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 Some(v) = self.if_in.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.if_out.as_ref() {
            os.write_string(2, v)?;
        }
        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() -> Criu_veth_pair {
        Criu_veth_pair::new()
    }

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

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

impl ::protobuf::MessageFull for Criu_veth_pair {
    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("criu_veth_pair").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:ext_mount_map)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Ext_mount_map {
    // message fields
    // @@protoc_insertion_point(field:ext_mount_map.key)
    pub key: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:ext_mount_map.val)
    pub val: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:ext_mount_map.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required string key = 1;

    pub fn key(&self) -> &str {
        match self.key.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

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

    // Param is passed by value, moved
    pub fn set_key(&mut self, v: ::std::string::String) {
        self.key = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_key(&mut self) -> &mut ::std::string::String {
        if self.key.is_none() {
            self.key = ::std::option::Option::Some(::std::string::String::new());
        }
        self.key.as_mut().unwrap()
    }

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

    // required string val = 2;

    pub fn val(&self) -> &str {
        match self.val.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_val(&self) -> bool {
        self.val.is_some()
    }

    // Param is passed by value, moved
    pub fn set_val(&mut self, v: ::std::string::String) {
        self.val = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_val(&mut self) -> &mut ::std::string::String {
        if self.val.is_none() {
            self.val = ::std::option::Option::Some(::std::string::String::new());
        }
        self.val.as_mut().unwrap()
    }

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

    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_option_accessor::<_, _>(
            "key",
            |m: &Ext_mount_map| { &m.key },
            |m: &mut Ext_mount_map| { &mut m.key },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "val",
            |m: &Ext_mount_map| { &m.val },
            |m: &mut Ext_mount_map| { &mut m.val },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Ext_mount_map>(
            "ext_mount_map",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.key.is_none() {
            return false;
        }
        if self.val.is_none() {
            return false;
        }
        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.key = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.val = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.key.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.val.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        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 Some(v) = self.key.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.val.as_ref() {
            os.write_string(2, v)?;
        }
        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() -> Ext_mount_map {
        Ext_mount_map::new()
    }

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

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

impl ::protobuf::MessageFull for Ext_mount_map {
    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("ext_mount_map").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:join_namespace)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Join_namespace {
    // message fields
    // @@protoc_insertion_point(field:join_namespace.ns)
    pub ns: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:join_namespace.ns_file)
    pub ns_file: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:join_namespace.extra_opt)
    pub extra_opt: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:join_namespace.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required string ns = 1;

    pub fn ns(&self) -> &str {
        match self.ns.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_ns(&self) -> bool {
        self.ns.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ns(&mut self, v: ::std::string::String) {
        self.ns = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ns(&mut self) -> &mut ::std::string::String {
        if self.ns.is_none() {
            self.ns = ::std::option::Option::Some(::std::string::String::new());
        }
        self.ns.as_mut().unwrap()
    }

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

    // required string ns_file = 2;

    pub fn ns_file(&self) -> &str {
        match self.ns_file.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_ns_file(&self) -> bool {
        self.ns_file.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ns_file(&mut self, v: ::std::string::String) {
        self.ns_file = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ns_file(&mut self) -> &mut ::std::string::String {
        if self.ns_file.is_none() {
            self.ns_file = ::std::option::Option::Some(::std::string::String::new());
        }
        self.ns_file.as_mut().unwrap()
    }

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

    // optional string extra_opt = 3;

    pub fn extra_opt(&self) -> &str {
        match self.extra_opt.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_extra_opt(&self) -> bool {
        self.extra_opt.is_some()
    }

    // Param is passed by value, moved
    pub fn set_extra_opt(&mut self, v: ::std::string::String) {
        self.extra_opt = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_extra_opt(&mut self) -> &mut ::std::string::String {
        if self.extra_opt.is_none() {
            self.extra_opt = ::std::option::Option::Some(::std::string::String::new());
        }
        self.extra_opt.as_mut().unwrap()
    }

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

    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_option_accessor::<_, _>(
            "ns",
            |m: &Join_namespace| { &m.ns },
            |m: &mut Join_namespace| { &mut m.ns },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "ns_file",
            |m: &Join_namespace| { &m.ns_file },
            |m: &mut Join_namespace| { &mut m.ns_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "extra_opt",
            |m: &Join_namespace| { &m.extra_opt },
            |m: &mut Join_namespace| { &mut m.extra_opt },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Join_namespace>(
            "join_namespace",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.ns.is_none() {
            return false;
        }
        if self.ns_file.is_none() {
            return false;
        }
        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.ns = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.ns_file = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.extra_opt = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.ns.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.ns_file.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.extra_opt.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        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 Some(v) = self.ns.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.ns_file.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.extra_opt.as_ref() {
            os.write_string(3, v)?;
        }
        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() -> Join_namespace {
        Join_namespace::new()
    }

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

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

impl ::protobuf::MessageFull for Join_namespace {
    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("join_namespace").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:inherit_fd)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Inherit_fd {
    // message fields
    // @@protoc_insertion_point(field:inherit_fd.key)
    pub key: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:inherit_fd.fd)
    pub fd: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:inherit_fd.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required string key = 1;

    pub fn key(&self) -> &str {
        match self.key.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

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

    // Param is passed by value, moved
    pub fn set_key(&mut self, v: ::std::string::String) {
        self.key = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_key(&mut self) -> &mut ::std::string::String {
        if self.key.is_none() {
            self.key = ::std::option::Option::Some(::std::string::String::new());
        }
        self.key.as_mut().unwrap()
    }

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

    // required int32 fd = 2;

    pub fn fd(&self) -> i32 {
        self.fd.unwrap_or(0)
    }

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

    pub fn has_fd(&self) -> bool {
        self.fd.is_some()
    }

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

    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_option_accessor::<_, _>(
            "key",
            |m: &Inherit_fd| { &m.key },
            |m: &mut Inherit_fd| { &mut m.key },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "fd",
            |m: &Inherit_fd| { &m.fd },
            |m: &mut Inherit_fd| { &mut m.fd },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Inherit_fd>(
            "inherit_fd",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.key.is_none() {
            return false;
        }
        if self.fd.is_none() {
            return false;
        }
        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.key = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.fd = ::std::option::Option::Some(is.read_int32()?);
                },
                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 Some(v) = self.key.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.fd {
            my_size += ::protobuf::rt::int32_size(2, v);
        }
        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 Some(v) = self.key.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.fd {
            os.write_int32(2, v)?;
        }
        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() -> Inherit_fd {
        Inherit_fd::new()
    }

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

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

impl ::protobuf::MessageFull for Inherit_fd {
    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("inherit_fd").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:cgroup_root)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Cgroup_root {
    // message fields
    // @@protoc_insertion_point(field:cgroup_root.ctrl)
    pub ctrl: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:cgroup_root.path)
    pub path: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:cgroup_root.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional string ctrl = 1;

    pub fn ctrl(&self) -> &str {
        match self.ctrl.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_ctrl(&self) -> bool {
        self.ctrl.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ctrl(&mut self, v: ::std::string::String) {
        self.ctrl = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ctrl(&mut self) -> &mut ::std::string::String {
        if self.ctrl.is_none() {
            self.ctrl = ::std::option::Option::Some(::std::string::String::new());
        }
        self.ctrl.as_mut().unwrap()
    }

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

    // required string path = 2;

    pub fn path(&self) -> &str {
        match self.path.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_path(&self) -> bool {
        self.path.is_some()
    }

    // Param is passed by value, moved
    pub fn set_path(&mut self, v: ::std::string::String) {
        self.path = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_path(&mut self) -> &mut ::std::string::String {
        if self.path.is_none() {
            self.path = ::std::option::Option::Some(::std::string::String::new());
        }
        self.path.as_mut().unwrap()
    }

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

    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_option_accessor::<_, _>(
            "ctrl",
            |m: &Cgroup_root| { &m.ctrl },
            |m: &mut Cgroup_root| { &mut m.ctrl },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "path",
            |m: &Cgroup_root| { &m.path },
            |m: &mut Cgroup_root| { &mut m.path },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Cgroup_root>(
            "cgroup_root",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.path.is_none() {
            return false;
        }
        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.ctrl = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.path = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.ctrl.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.path.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        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 Some(v) = self.ctrl.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.path.as_ref() {
            os.write_string(2, v)?;
        }
        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() -> Cgroup_root {
        Cgroup_root::new()
    }

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

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

impl ::protobuf::MessageFull for Cgroup_root {
    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("cgroup_root").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:unix_sk)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Unix_sk {
    // message fields
    // @@protoc_insertion_point(field:unix_sk.inode)
    pub inode: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:unix_sk.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required uint32 inode = 1;

    pub fn inode(&self) -> u32 {
        self.inode.unwrap_or(0)
    }

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

    pub fn has_inode(&self) -> bool {
        self.inode.is_some()
    }

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

    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_option_accessor::<_, _>(
            "inode",
            |m: &Unix_sk| { &m.inode },
            |m: &mut Unix_sk| { &mut m.inode },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Unix_sk>(
            "unix_sk",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.inode.is_none() {
            return false;
        }
        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.inode = ::std::option::Option::Some(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 let Some(v) = self.inode {
            my_size += ::protobuf::rt::uint32_size(1, v);
        }
        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 Some(v) = self.inode {
            os.write_uint32(1, v)?;
        }
        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() -> Unix_sk {
        Unix_sk::new()
    }

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

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

impl ::protobuf::MessageFull for Unix_sk {
    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("unix_sk").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_opts)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_opts {
    // message fields
    // @@protoc_insertion_point(field:criu_opts.images_dir_fd)
    pub images_dir_fd: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_opts.images_dir)
    pub images_dir: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.pid)
    pub pid: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_opts.leave_running)
    pub leave_running: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.ext_unix_sk)
    pub ext_unix_sk: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.tcp_established)
    pub tcp_established: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.evasive_devices)
    pub evasive_devices: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.shell_job)
    pub shell_job: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.file_locks)
    pub file_locks: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.log_level)
    pub log_level: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_opts.log_file)
    pub log_file: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.ps)
    pub ps: ::protobuf::MessageField<Criu_page_server_info>,
    // @@protoc_insertion_point(field:criu_opts.notify_scripts)
    pub notify_scripts: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.root)
    pub root: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.parent_img)
    pub parent_img: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.track_mem)
    pub track_mem: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.auto_dedup)
    pub auto_dedup: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.work_dir_fd)
    pub work_dir_fd: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_opts.link_remap)
    pub link_remap: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.veths)
    pub veths: ::std::vec::Vec<Criu_veth_pair>,
    // @@protoc_insertion_point(field:criu_opts.cpu_cap)
    pub cpu_cap: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:criu_opts.force_irmap)
    pub force_irmap: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.exec_cmd)
    pub exec_cmd: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.ext_mnt)
    pub ext_mnt: ::std::vec::Vec<Ext_mount_map>,
    // @@protoc_insertion_point(field:criu_opts.manage_cgroups)
    pub manage_cgroups: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.cg_root)
    pub cg_root: ::std::vec::Vec<Cgroup_root>,
    // @@protoc_insertion_point(field:criu_opts.rst_sibling)
    pub rst_sibling: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.inherit_fd)
    pub inherit_fd: ::std::vec::Vec<Inherit_fd>,
    // @@protoc_insertion_point(field:criu_opts.auto_ext_mnt)
    pub auto_ext_mnt: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.ext_sharing)
    pub ext_sharing: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.ext_masters)
    pub ext_masters: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.skip_mnt)
    pub skip_mnt: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.enable_fs)
    pub enable_fs: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.unix_sk_ino)
    pub unix_sk_ino: ::std::vec::Vec<Unix_sk>,
    // @@protoc_insertion_point(field:criu_opts.manage_cgroups_mode)
    pub manage_cgroups_mode: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_cg_mode>>,
    // @@protoc_insertion_point(field:criu_opts.ghost_limit)
    pub ghost_limit: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:criu_opts.irmap_scan_paths)
    pub irmap_scan_paths: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.external)
    pub external: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.empty_ns)
    pub empty_ns: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:criu_opts.join_ns)
    pub join_ns: ::std::vec::Vec<Join_namespace>,
    // @@protoc_insertion_point(field:criu_opts.cgroup_props)
    pub cgroup_props: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.cgroup_props_file)
    pub cgroup_props_file: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.cgroup_dump_controller)
    pub cgroup_dump_controller: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.freeze_cgroup)
    pub freeze_cgroup: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.timeout)
    pub timeout: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:criu_opts.tcp_skip_in_flight)
    pub tcp_skip_in_flight: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.weak_sysctls)
    pub weak_sysctls: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.lazy_pages)
    pub lazy_pages: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.status_fd)
    pub status_fd: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_opts.orphan_pts_master)
    pub orphan_pts_master: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.config_file)
    pub config_file: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.tcp_close)
    pub tcp_close: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.lsm_profile)
    pub lsm_profile: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.tls_cacert)
    pub tls_cacert: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.tls_cacrl)
    pub tls_cacrl: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.tls_cert)
    pub tls_cert: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.tls_key)
    pub tls_key: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.tls)
    pub tls: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.tls_no_cn_verify)
    pub tls_no_cn_verify: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.cgroup_yard)
    pub cgroup_yard: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.pre_dump_mode)
    pub pre_dump_mode: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_pre_dump_mode>>,
    // @@protoc_insertion_point(field:criu_opts.pidfd_store_sk)
    pub pidfd_store_sk: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_opts.lsm_mount_context)
    pub lsm_mount_context: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_opts.network_lock)
    pub network_lock: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_network_lock_method>>,
    // @@protoc_insertion_point(field:criu_opts.mntns_compat_mode)
    pub mntns_compat_mode: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.skip_file_rwx_check)
    pub skip_file_rwx_check: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.unprivileged)
    pub unprivileged: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.leave_stopped)
    pub leave_stopped: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.display_stats)
    pub display_stats: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_opts.log_to_stderr)
    pub log_to_stderr: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_opts.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required int32 images_dir_fd = 1;

    pub fn images_dir_fd(&self) -> i32 {
        self.images_dir_fd.unwrap_or(-1i32)
    }

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

    pub fn has_images_dir_fd(&self) -> bool {
        self.images_dir_fd.is_some()
    }

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

    // optional string images_dir = 68;

    pub fn images_dir(&self) -> &str {
        match self.images_dir.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_images_dir(&self) -> bool {
        self.images_dir.is_some()
    }

    // Param is passed by value, moved
    pub fn set_images_dir(&mut self, v: ::std::string::String) {
        self.images_dir = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_images_dir(&mut self) -> &mut ::std::string::String {
        if self.images_dir.is_none() {
            self.images_dir = ::std::option::Option::Some(::std::string::String::new());
        }
        self.images_dir.as_mut().unwrap()
    }

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

    // optional int32 pid = 2;

    pub fn pid(&self) -> i32 {
        self.pid.unwrap_or(0)
    }

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

    pub fn has_pid(&self) -> bool {
        self.pid.is_some()
    }

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

    // optional bool leave_running = 3;

    pub fn leave_running(&self) -> bool {
        self.leave_running.unwrap_or(false)
    }

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

    pub fn has_leave_running(&self) -> bool {
        self.leave_running.is_some()
    }

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

    // optional bool ext_unix_sk = 4;

    pub fn ext_unix_sk(&self) -> bool {
        self.ext_unix_sk.unwrap_or(false)
    }

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

    pub fn has_ext_unix_sk(&self) -> bool {
        self.ext_unix_sk.is_some()
    }

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

    // optional bool tcp_established = 5;

    pub fn tcp_established(&self) -> bool {
        self.tcp_established.unwrap_or(false)
    }

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

    pub fn has_tcp_established(&self) -> bool {
        self.tcp_established.is_some()
    }

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

    // optional bool evasive_devices = 6;

    pub fn evasive_devices(&self) -> bool {
        self.evasive_devices.unwrap_or(false)
    }

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

    pub fn has_evasive_devices(&self) -> bool {
        self.evasive_devices.is_some()
    }

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

    // optional bool shell_job = 7;

    pub fn shell_job(&self) -> bool {
        self.shell_job.unwrap_or(false)
    }

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

    pub fn has_shell_job(&self) -> bool {
        self.shell_job.is_some()
    }

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

    // optional bool file_locks = 8;

    pub fn file_locks(&self) -> bool {
        self.file_locks.unwrap_or(false)
    }

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

    pub fn has_file_locks(&self) -> bool {
        self.file_locks.is_some()
    }

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

    // optional int32 log_level = 9;

    pub fn log_level(&self) -> i32 {
        self.log_level.unwrap_or(2i32)
    }

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

    pub fn has_log_level(&self) -> bool {
        self.log_level.is_some()
    }

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

    // optional string log_file = 10;

    pub fn log_file(&self) -> &str {
        match self.log_file.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_log_file(&self) -> bool {
        self.log_file.is_some()
    }

    // Param is passed by value, moved
    pub fn set_log_file(&mut self, v: ::std::string::String) {
        self.log_file = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_log_file(&mut self) -> &mut ::std::string::String {
        if self.log_file.is_none() {
            self.log_file = ::std::option::Option::Some(::std::string::String::new());
        }
        self.log_file.as_mut().unwrap()
    }

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

    // optional bool notify_scripts = 12;

    pub fn notify_scripts(&self) -> bool {
        self.notify_scripts.unwrap_or(false)
    }

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

    pub fn has_notify_scripts(&self) -> bool {
        self.notify_scripts.is_some()
    }

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

    // optional string root = 13;

    pub fn root(&self) -> &str {
        match self.root.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_root(&self) -> bool {
        self.root.is_some()
    }

    // Param is passed by value, moved
    pub fn set_root(&mut self, v: ::std::string::String) {
        self.root = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_root(&mut self) -> &mut ::std::string::String {
        if self.root.is_none() {
            self.root = ::std::option::Option::Some(::std::string::String::new());
        }
        self.root.as_mut().unwrap()
    }

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

    // optional string parent_img = 14;

    pub fn parent_img(&self) -> &str {
        match self.parent_img.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_parent_img(&self) -> bool {
        self.parent_img.is_some()
    }

    // Param is passed by value, moved
    pub fn set_parent_img(&mut self, v: ::std::string::String) {
        self.parent_img = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_parent_img(&mut self) -> &mut ::std::string::String {
        if self.parent_img.is_none() {
            self.parent_img = ::std::option::Option::Some(::std::string::String::new());
        }
        self.parent_img.as_mut().unwrap()
    }

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

    // optional bool track_mem = 15;

    pub fn track_mem(&self) -> bool {
        self.track_mem.unwrap_or(false)
    }

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

    pub fn has_track_mem(&self) -> bool {
        self.track_mem.is_some()
    }

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

    // optional bool auto_dedup = 16;

    pub fn auto_dedup(&self) -> bool {
        self.auto_dedup.unwrap_or(false)
    }

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

    pub fn has_auto_dedup(&self) -> bool {
        self.auto_dedup.is_some()
    }

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

    // optional int32 work_dir_fd = 17;

    pub fn work_dir_fd(&self) -> i32 {
        self.work_dir_fd.unwrap_or(0)
    }

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

    pub fn has_work_dir_fd(&self) -> bool {
        self.work_dir_fd.is_some()
    }

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

    // optional bool link_remap = 18;

    pub fn link_remap(&self) -> bool {
        self.link_remap.unwrap_or(false)
    }

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

    pub fn has_link_remap(&self) -> bool {
        self.link_remap.is_some()
    }

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

    // optional uint32 cpu_cap = 20;

    pub fn cpu_cap(&self) -> u32 {
        self.cpu_cap.unwrap_or(4294967295u32)
    }

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

    pub fn has_cpu_cap(&self) -> bool {
        self.cpu_cap.is_some()
    }

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

    // optional bool force_irmap = 21;

    pub fn force_irmap(&self) -> bool {
        self.force_irmap.unwrap_or(false)
    }

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

    pub fn has_force_irmap(&self) -> bool {
        self.force_irmap.is_some()
    }

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

    // optional bool manage_cgroups = 24;

    pub fn manage_cgroups(&self) -> bool {
        self.manage_cgroups.unwrap_or(false)
    }

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

    pub fn has_manage_cgroups(&self) -> bool {
        self.manage_cgroups.is_some()
    }

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

    // optional bool rst_sibling = 26;

    pub fn rst_sibling(&self) -> bool {
        self.rst_sibling.unwrap_or(false)
    }

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

    pub fn has_rst_sibling(&self) -> bool {
        self.rst_sibling.is_some()
    }

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

    // optional bool auto_ext_mnt = 28;

    pub fn auto_ext_mnt(&self) -> bool {
        self.auto_ext_mnt.unwrap_or(false)
    }

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

    pub fn has_auto_ext_mnt(&self) -> bool {
        self.auto_ext_mnt.is_some()
    }

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

    // optional bool ext_sharing = 29;

    pub fn ext_sharing(&self) -> bool {
        self.ext_sharing.unwrap_or(false)
    }

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

    pub fn has_ext_sharing(&self) -> bool {
        self.ext_sharing.is_some()
    }

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

    // optional bool ext_masters = 30;

    pub fn ext_masters(&self) -> bool {
        self.ext_masters.unwrap_or(false)
    }

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

    pub fn has_ext_masters(&self) -> bool {
        self.ext_masters.is_some()
    }

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

    // optional .criu_cg_mode manage_cgroups_mode = 34;

    pub fn manage_cgroups_mode(&self) -> Criu_cg_mode {
        match self.manage_cgroups_mode {
            Some(e) => e.enum_value_or(Criu_cg_mode::IGNORE),
            None => Criu_cg_mode::IGNORE,
        }
    }

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

    pub fn has_manage_cgroups_mode(&self) -> bool {
        self.manage_cgroups_mode.is_some()
    }

    // Param is passed by value, moved
    pub fn set_manage_cgroups_mode(&mut self, v: Criu_cg_mode) {
        self.manage_cgroups_mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    // optional uint32 ghost_limit = 35;

    pub fn ghost_limit(&self) -> u32 {
        self.ghost_limit.unwrap_or(1048576u32)
    }

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

    pub fn has_ghost_limit(&self) -> bool {
        self.ghost_limit.is_some()
    }

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

    // optional uint32 empty_ns = 38;

    pub fn empty_ns(&self) -> u32 {
        self.empty_ns.unwrap_or(0)
    }

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

    pub fn has_empty_ns(&self) -> bool {
        self.empty_ns.is_some()
    }

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

    // optional string cgroup_props = 41;

    pub fn cgroup_props(&self) -> &str {
        match self.cgroup_props.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_cgroup_props(&self) -> bool {
        self.cgroup_props.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cgroup_props(&mut self, v: ::std::string::String) {
        self.cgroup_props = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cgroup_props(&mut self) -> &mut ::std::string::String {
        if self.cgroup_props.is_none() {
            self.cgroup_props = ::std::option::Option::Some(::std::string::String::new());
        }
        self.cgroup_props.as_mut().unwrap()
    }

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

    // optional string cgroup_props_file = 42;

    pub fn cgroup_props_file(&self) -> &str {
        match self.cgroup_props_file.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_cgroup_props_file(&self) -> bool {
        self.cgroup_props_file.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cgroup_props_file(&mut self, v: ::std::string::String) {
        self.cgroup_props_file = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cgroup_props_file(&mut self) -> &mut ::std::string::String {
        if self.cgroup_props_file.is_none() {
            self.cgroup_props_file = ::std::option::Option::Some(::std::string::String::new());
        }
        self.cgroup_props_file.as_mut().unwrap()
    }

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

    // optional string freeze_cgroup = 44;

    pub fn freeze_cgroup(&self) -> &str {
        match self.freeze_cgroup.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_freeze_cgroup(&self) -> bool {
        self.freeze_cgroup.is_some()
    }

    // Param is passed by value, moved
    pub fn set_freeze_cgroup(&mut self, v: ::std::string::String) {
        self.freeze_cgroup = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_freeze_cgroup(&mut self) -> &mut ::std::string::String {
        if self.freeze_cgroup.is_none() {
            self.freeze_cgroup = ::std::option::Option::Some(::std::string::String::new());
        }
        self.freeze_cgroup.as_mut().unwrap()
    }

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

    // optional uint32 timeout = 45;

    pub fn timeout(&self) -> u32 {
        self.timeout.unwrap_or(0)
    }

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

    pub fn has_timeout(&self) -> bool {
        self.timeout.is_some()
    }

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

    // optional bool tcp_skip_in_flight = 46;

    pub fn tcp_skip_in_flight(&self) -> bool {
        self.tcp_skip_in_flight.unwrap_or(false)
    }

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

    pub fn has_tcp_skip_in_flight(&self) -> bool {
        self.tcp_skip_in_flight.is_some()
    }

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

    // optional bool weak_sysctls = 47;

    pub fn weak_sysctls(&self) -> bool {
        self.weak_sysctls.unwrap_or(false)
    }

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

    pub fn has_weak_sysctls(&self) -> bool {
        self.weak_sysctls.is_some()
    }

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

    // optional bool lazy_pages = 48;

    pub fn lazy_pages(&self) -> bool {
        self.lazy_pages.unwrap_or(false)
    }

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

    pub fn has_lazy_pages(&self) -> bool {
        self.lazy_pages.is_some()
    }

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

    // optional int32 status_fd = 49;

    pub fn status_fd(&self) -> i32 {
        self.status_fd.unwrap_or(0)
    }

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

    pub fn has_status_fd(&self) -> bool {
        self.status_fd.is_some()
    }

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

    // optional bool orphan_pts_master = 50;

    pub fn orphan_pts_master(&self) -> bool {
        self.orphan_pts_master.unwrap_or(false)
    }

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

    pub fn has_orphan_pts_master(&self) -> bool {
        self.orphan_pts_master.is_some()
    }

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

    // optional string config_file = 51;

    pub fn config_file(&self) -> &str {
        match self.config_file.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_config_file(&self) -> bool {
        self.config_file.is_some()
    }

    // Param is passed by value, moved
    pub fn set_config_file(&mut self, v: ::std::string::String) {
        self.config_file = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_config_file(&mut self) -> &mut ::std::string::String {
        if self.config_file.is_none() {
            self.config_file = ::std::option::Option::Some(::std::string::String::new());
        }
        self.config_file.as_mut().unwrap()
    }

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

    // optional bool tcp_close = 52;

    pub fn tcp_close(&self) -> bool {
        self.tcp_close.unwrap_or(false)
    }

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

    pub fn has_tcp_close(&self) -> bool {
        self.tcp_close.is_some()
    }

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

    // optional string lsm_profile = 53;

    pub fn lsm_profile(&self) -> &str {
        match self.lsm_profile.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_lsm_profile(&self) -> bool {
        self.lsm_profile.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lsm_profile(&mut self, v: ::std::string::String) {
        self.lsm_profile = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_lsm_profile(&mut self) -> &mut ::std::string::String {
        if self.lsm_profile.is_none() {
            self.lsm_profile = ::std::option::Option::Some(::std::string::String::new());
        }
        self.lsm_profile.as_mut().unwrap()
    }

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

    // optional string tls_cacert = 54;

    pub fn tls_cacert(&self) -> &str {
        match self.tls_cacert.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_tls_cacert(&self) -> bool {
        self.tls_cacert.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tls_cacert(&mut self, v: ::std::string::String) {
        self.tls_cacert = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tls_cacert(&mut self) -> &mut ::std::string::String {
        if self.tls_cacert.is_none() {
            self.tls_cacert = ::std::option::Option::Some(::std::string::String::new());
        }
        self.tls_cacert.as_mut().unwrap()
    }

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

    // optional string tls_cacrl = 55;

    pub fn tls_cacrl(&self) -> &str {
        match self.tls_cacrl.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_tls_cacrl(&self) -> bool {
        self.tls_cacrl.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tls_cacrl(&mut self, v: ::std::string::String) {
        self.tls_cacrl = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tls_cacrl(&mut self) -> &mut ::std::string::String {
        if self.tls_cacrl.is_none() {
            self.tls_cacrl = ::std::option::Option::Some(::std::string::String::new());
        }
        self.tls_cacrl.as_mut().unwrap()
    }

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

    // optional string tls_cert = 56;

    pub fn tls_cert(&self) -> &str {
        match self.tls_cert.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_tls_cert(&self) -> bool {
        self.tls_cert.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tls_cert(&mut self, v: ::std::string::String) {
        self.tls_cert = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tls_cert(&mut self) -> &mut ::std::string::String {
        if self.tls_cert.is_none() {
            self.tls_cert = ::std::option::Option::Some(::std::string::String::new());
        }
        self.tls_cert.as_mut().unwrap()
    }

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

    // optional string tls_key = 57;

    pub fn tls_key(&self) -> &str {
        match self.tls_key.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_tls_key(&self) -> bool {
        self.tls_key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tls_key(&mut self, v: ::std::string::String) {
        self.tls_key = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tls_key(&mut self) -> &mut ::std::string::String {
        if self.tls_key.is_none() {
            self.tls_key = ::std::option::Option::Some(::std::string::String::new());
        }
        self.tls_key.as_mut().unwrap()
    }

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

    // optional bool tls = 58;

    pub fn tls(&self) -> bool {
        self.tls.unwrap_or(false)
    }

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

    pub fn has_tls(&self) -> bool {
        self.tls.is_some()
    }

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

    // optional bool tls_no_cn_verify = 59;

    pub fn tls_no_cn_verify(&self) -> bool {
        self.tls_no_cn_verify.unwrap_or(false)
    }

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

    pub fn has_tls_no_cn_verify(&self) -> bool {
        self.tls_no_cn_verify.is_some()
    }

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

    // optional string cgroup_yard = 60;

    pub fn cgroup_yard(&self) -> &str {
        match self.cgroup_yard.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_cgroup_yard(&self) -> bool {
        self.cgroup_yard.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cgroup_yard(&mut self, v: ::std::string::String) {
        self.cgroup_yard = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cgroup_yard(&mut self) -> &mut ::std::string::String {
        if self.cgroup_yard.is_none() {
            self.cgroup_yard = ::std::option::Option::Some(::std::string::String::new());
        }
        self.cgroup_yard.as_mut().unwrap()
    }

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

    // optional .criu_pre_dump_mode pre_dump_mode = 61;

    pub fn pre_dump_mode(&self) -> Criu_pre_dump_mode {
        match self.pre_dump_mode {
            Some(e) => e.enum_value_or(Criu_pre_dump_mode::SPLICE),
            None => Criu_pre_dump_mode::SPLICE,
        }
    }

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

    pub fn has_pre_dump_mode(&self) -> bool {
        self.pre_dump_mode.is_some()
    }

    // Param is passed by value, moved
    pub fn set_pre_dump_mode(&mut self, v: Criu_pre_dump_mode) {
        self.pre_dump_mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    // optional int32 pidfd_store_sk = 62;

    pub fn pidfd_store_sk(&self) -> i32 {
        self.pidfd_store_sk.unwrap_or(0)
    }

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

    pub fn has_pidfd_store_sk(&self) -> bool {
        self.pidfd_store_sk.is_some()
    }

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

    // optional string lsm_mount_context = 63;

    pub fn lsm_mount_context(&self) -> &str {
        match self.lsm_mount_context.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_lsm_mount_context(&self) -> bool {
        self.lsm_mount_context.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lsm_mount_context(&mut self, v: ::std::string::String) {
        self.lsm_mount_context = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_lsm_mount_context(&mut self) -> &mut ::std::string::String {
        if self.lsm_mount_context.is_none() {
            self.lsm_mount_context = ::std::option::Option::Some(::std::string::String::new());
        }
        self.lsm_mount_context.as_mut().unwrap()
    }

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

    // optional .criu_network_lock_method network_lock = 64;

    pub fn network_lock(&self) -> Criu_network_lock_method {
        match self.network_lock {
            Some(e) => e.enum_value_or(Criu_network_lock_method::IPTABLES),
            None => Criu_network_lock_method::IPTABLES,
        }
    }

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

    pub fn has_network_lock(&self) -> bool {
        self.network_lock.is_some()
    }

    // Param is passed by value, moved
    pub fn set_network_lock(&mut self, v: Criu_network_lock_method) {
        self.network_lock = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool mntns_compat_mode = 65;

    pub fn mntns_compat_mode(&self) -> bool {
        self.mntns_compat_mode.unwrap_or(false)
    }

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

    pub fn has_mntns_compat_mode(&self) -> bool {
        self.mntns_compat_mode.is_some()
    }

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

    // optional bool skip_file_rwx_check = 66;

    pub fn skip_file_rwx_check(&self) -> bool {
        self.skip_file_rwx_check.unwrap_or(false)
    }

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

    pub fn has_skip_file_rwx_check(&self) -> bool {
        self.skip_file_rwx_check.is_some()
    }

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

    // optional bool unprivileged = 67;

    pub fn unprivileged(&self) -> bool {
        self.unprivileged.unwrap_or(false)
    }

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

    pub fn has_unprivileged(&self) -> bool {
        self.unprivileged.is_some()
    }

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

    // optional bool leave_stopped = 69;

    pub fn leave_stopped(&self) -> bool {
        self.leave_stopped.unwrap_or(false)
    }

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

    pub fn has_leave_stopped(&self) -> bool {
        self.leave_stopped.is_some()
    }

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

    // optional bool display_stats = 70;

    pub fn display_stats(&self) -> bool {
        self.display_stats.unwrap_or(false)
    }

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

    pub fn has_display_stats(&self) -> bool {
        self.display_stats.is_some()
    }

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

    // optional bool log_to_stderr = 71;

    pub fn log_to_stderr(&self) -> bool {
        self.log_to_stderr.unwrap_or(false)
    }

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

    pub fn has_log_to_stderr(&self) -> bool {
        self.log_to_stderr.is_some()
    }

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(70);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "images_dir_fd",
            |m: &Criu_opts| { &m.images_dir_fd },
            |m: &mut Criu_opts| { &mut m.images_dir_fd },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "images_dir",
            |m: &Criu_opts| { &m.images_dir },
            |m: &mut Criu_opts| { &mut m.images_dir },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pid",
            |m: &Criu_opts| { &m.pid },
            |m: &mut Criu_opts| { &mut m.pid },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "leave_running",
            |m: &Criu_opts| { &m.leave_running },
            |m: &mut Criu_opts| { &mut m.leave_running },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "ext_unix_sk",
            |m: &Criu_opts| { &m.ext_unix_sk },
            |m: &mut Criu_opts| { &mut m.ext_unix_sk },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tcp_established",
            |m: &Criu_opts| { &m.tcp_established },
            |m: &mut Criu_opts| { &mut m.tcp_established },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "evasive_devices",
            |m: &Criu_opts| { &m.evasive_devices },
            |m: &mut Criu_opts| { &mut m.evasive_devices },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "shell_job",
            |m: &Criu_opts| { &m.shell_job },
            |m: &mut Criu_opts| { &mut m.shell_job },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "file_locks",
            |m: &Criu_opts| { &m.file_locks },
            |m: &mut Criu_opts| { &mut m.file_locks },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "log_level",
            |m: &Criu_opts| { &m.log_level },
            |m: &mut Criu_opts| { &mut m.log_level },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "log_file",
            |m: &Criu_opts| { &m.log_file },
            |m: &mut Criu_opts| { &mut m.log_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_page_server_info>(
            "ps",
            |m: &Criu_opts| { &m.ps },
            |m: &mut Criu_opts| { &mut m.ps },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "notify_scripts",
            |m: &Criu_opts| { &m.notify_scripts },
            |m: &mut Criu_opts| { &mut m.notify_scripts },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "root",
            |m: &Criu_opts| { &m.root },
            |m: &mut Criu_opts| { &mut m.root },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "parent_img",
            |m: &Criu_opts| { &m.parent_img },
            |m: &mut Criu_opts| { &mut m.parent_img },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "track_mem",
            |m: &Criu_opts| { &m.track_mem },
            |m: &mut Criu_opts| { &mut m.track_mem },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "auto_dedup",
            |m: &Criu_opts| { &m.auto_dedup },
            |m: &mut Criu_opts| { &mut m.auto_dedup },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "work_dir_fd",
            |m: &Criu_opts| { &m.work_dir_fd },
            |m: &mut Criu_opts| { &mut m.work_dir_fd },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "link_remap",
            |m: &Criu_opts| { &m.link_remap },
            |m: &mut Criu_opts| { &mut m.link_remap },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "veths",
            |m: &Criu_opts| { &m.veths },
            |m: &mut Criu_opts| { &mut m.veths },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "cpu_cap",
            |m: &Criu_opts| { &m.cpu_cap },
            |m: &mut Criu_opts| { &mut m.cpu_cap },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "force_irmap",
            |m: &Criu_opts| { &m.force_irmap },
            |m: &mut Criu_opts| { &mut m.force_irmap },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "exec_cmd",
            |m: &Criu_opts| { &m.exec_cmd },
            |m: &mut Criu_opts| { &mut m.exec_cmd },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "ext_mnt",
            |m: &Criu_opts| { &m.ext_mnt },
            |m: &mut Criu_opts| { &mut m.ext_mnt },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "manage_cgroups",
            |m: &Criu_opts| { &m.manage_cgroups },
            |m: &mut Criu_opts| { &mut m.manage_cgroups },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "cg_root",
            |m: &Criu_opts| { &m.cg_root },
            |m: &mut Criu_opts| { &mut m.cg_root },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "rst_sibling",
            |m: &Criu_opts| { &m.rst_sibling },
            |m: &mut Criu_opts| { &mut m.rst_sibling },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "inherit_fd",
            |m: &Criu_opts| { &m.inherit_fd },
            |m: &mut Criu_opts| { &mut m.inherit_fd },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "auto_ext_mnt",
            |m: &Criu_opts| { &m.auto_ext_mnt },
            |m: &mut Criu_opts| { &mut m.auto_ext_mnt },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "ext_sharing",
            |m: &Criu_opts| { &m.ext_sharing },
            |m: &mut Criu_opts| { &mut m.ext_sharing },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "ext_masters",
            |m: &Criu_opts| { &m.ext_masters },
            |m: &mut Criu_opts| { &mut m.ext_masters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "skip_mnt",
            |m: &Criu_opts| { &m.skip_mnt },
            |m: &mut Criu_opts| { &mut m.skip_mnt },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "enable_fs",
            |m: &Criu_opts| { &m.enable_fs },
            |m: &mut Criu_opts| { &mut m.enable_fs },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "unix_sk_ino",
            |m: &Criu_opts| { &m.unix_sk_ino },
            |m: &mut Criu_opts| { &mut m.unix_sk_ino },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "manage_cgroups_mode",
            |m: &Criu_opts| { &m.manage_cgroups_mode },
            |m: &mut Criu_opts| { &mut m.manage_cgroups_mode },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "ghost_limit",
            |m: &Criu_opts| { &m.ghost_limit },
            |m: &mut Criu_opts| { &mut m.ghost_limit },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "irmap_scan_paths",
            |m: &Criu_opts| { &m.irmap_scan_paths },
            |m: &mut Criu_opts| { &mut m.irmap_scan_paths },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "external",
            |m: &Criu_opts| { &m.external },
            |m: &mut Criu_opts| { &mut m.external },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "empty_ns",
            |m: &Criu_opts| { &m.empty_ns },
            |m: &mut Criu_opts| { &mut m.empty_ns },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "join_ns",
            |m: &Criu_opts| { &m.join_ns },
            |m: &mut Criu_opts| { &mut m.join_ns },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "cgroup_props",
            |m: &Criu_opts| { &m.cgroup_props },
            |m: &mut Criu_opts| { &mut m.cgroup_props },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "cgroup_props_file",
            |m: &Criu_opts| { &m.cgroup_props_file },
            |m: &mut Criu_opts| { &mut m.cgroup_props_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "cgroup_dump_controller",
            |m: &Criu_opts| { &m.cgroup_dump_controller },
            |m: &mut Criu_opts| { &mut m.cgroup_dump_controller },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "freeze_cgroup",
            |m: &Criu_opts| { &m.freeze_cgroup },
            |m: &mut Criu_opts| { &mut m.freeze_cgroup },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "timeout",
            |m: &Criu_opts| { &m.timeout },
            |m: &mut Criu_opts| { &mut m.timeout },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tcp_skip_in_flight",
            |m: &Criu_opts| { &m.tcp_skip_in_flight },
            |m: &mut Criu_opts| { &mut m.tcp_skip_in_flight },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "weak_sysctls",
            |m: &Criu_opts| { &m.weak_sysctls },
            |m: &mut Criu_opts| { &mut m.weak_sysctls },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "lazy_pages",
            |m: &Criu_opts| { &m.lazy_pages },
            |m: &mut Criu_opts| { &mut m.lazy_pages },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "status_fd",
            |m: &Criu_opts| { &m.status_fd },
            |m: &mut Criu_opts| { &mut m.status_fd },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "orphan_pts_master",
            |m: &Criu_opts| { &m.orphan_pts_master },
            |m: &mut Criu_opts| { &mut m.orphan_pts_master },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "config_file",
            |m: &Criu_opts| { &m.config_file },
            |m: &mut Criu_opts| { &mut m.config_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tcp_close",
            |m: &Criu_opts| { &m.tcp_close },
            |m: &mut Criu_opts| { &mut m.tcp_close },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "lsm_profile",
            |m: &Criu_opts| { &m.lsm_profile },
            |m: &mut Criu_opts| { &mut m.lsm_profile },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tls_cacert",
            |m: &Criu_opts| { &m.tls_cacert },
            |m: &mut Criu_opts| { &mut m.tls_cacert },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tls_cacrl",
            |m: &Criu_opts| { &m.tls_cacrl },
            |m: &mut Criu_opts| { &mut m.tls_cacrl },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tls_cert",
            |m: &Criu_opts| { &m.tls_cert },
            |m: &mut Criu_opts| { &mut m.tls_cert },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tls_key",
            |m: &Criu_opts| { &m.tls_key },
            |m: &mut Criu_opts| { &mut m.tls_key },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tls",
            |m: &Criu_opts| { &m.tls },
            |m: &mut Criu_opts| { &mut m.tls },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "tls_no_cn_verify",
            |m: &Criu_opts| { &m.tls_no_cn_verify },
            |m: &mut Criu_opts| { &mut m.tls_no_cn_verify },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "cgroup_yard",
            |m: &Criu_opts| { &m.cgroup_yard },
            |m: &mut Criu_opts| { &mut m.cgroup_yard },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pre_dump_mode",
            |m: &Criu_opts| { &m.pre_dump_mode },
            |m: &mut Criu_opts| { &mut m.pre_dump_mode },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pidfd_store_sk",
            |m: &Criu_opts| { &m.pidfd_store_sk },
            |m: &mut Criu_opts| { &mut m.pidfd_store_sk },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "lsm_mount_context",
            |m: &Criu_opts| { &m.lsm_mount_context },
            |m: &mut Criu_opts| { &mut m.lsm_mount_context },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "network_lock",
            |m: &Criu_opts| { &m.network_lock },
            |m: &mut Criu_opts| { &mut m.network_lock },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "mntns_compat_mode",
            |m: &Criu_opts| { &m.mntns_compat_mode },
            |m: &mut Criu_opts| { &mut m.mntns_compat_mode },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "skip_file_rwx_check",
            |m: &Criu_opts| { &m.skip_file_rwx_check },
            |m: &mut Criu_opts| { &mut m.skip_file_rwx_check },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "unprivileged",
            |m: &Criu_opts| { &m.unprivileged },
            |m: &mut Criu_opts| { &mut m.unprivileged },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "leave_stopped",
            |m: &Criu_opts| { &m.leave_stopped },
            |m: &mut Criu_opts| { &mut m.leave_stopped },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "display_stats",
            |m: &Criu_opts| { &m.display_stats },
            |m: &mut Criu_opts| { &mut m.display_stats },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "log_to_stderr",
            |m: &Criu_opts| { &m.log_to_stderr },
            |m: &mut Criu_opts| { &mut m.log_to_stderr },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_opts>(
            "criu_opts",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.images_dir_fd.is_none() {
            return false;
        }
        for v in &self.ps {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.veths {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.ext_mnt {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.cg_root {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.inherit_fd {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.unix_sk_ino {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.join_ns {
            if !v.is_initialized() {
                return false;
            }
        };
        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.images_dir_fd = ::std::option::Option::Some(is.read_int32()?);
                },
                546 => {
                    self.images_dir = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.pid = ::std::option::Option::Some(is.read_int32()?);
                },
                24 => {
                    self.leave_running = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.ext_unix_sk = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.tcp_established = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.evasive_devices = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.shell_job = ::std::option::Option::Some(is.read_bool()?);
                },
                64 => {
                    self.file_locks = ::std::option::Option::Some(is.read_bool()?);
                },
                72 => {
                    self.log_level = ::std::option::Option::Some(is.read_int32()?);
                },
                82 => {
                    self.log_file = ::std::option::Option::Some(is.read_string()?);
                },
                90 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.ps)?;
                },
                96 => {
                    self.notify_scripts = ::std::option::Option::Some(is.read_bool()?);
                },
                106 => {
                    self.root = ::std::option::Option::Some(is.read_string()?);
                },
                114 => {
                    self.parent_img = ::std::option::Option::Some(is.read_string()?);
                },
                120 => {
                    self.track_mem = ::std::option::Option::Some(is.read_bool()?);
                },
                128 => {
                    self.auto_dedup = ::std::option::Option::Some(is.read_bool()?);
                },
                136 => {
                    self.work_dir_fd = ::std::option::Option::Some(is.read_int32()?);
                },
                144 => {
                    self.link_remap = ::std::option::Option::Some(is.read_bool()?);
                },
                154 => {
                    self.veths.push(is.read_message()?);
                },
                160 => {
                    self.cpu_cap = ::std::option::Option::Some(is.read_uint32()?);
                },
                168 => {
                    self.force_irmap = ::std::option::Option::Some(is.read_bool()?);
                },
                178 => {
                    self.exec_cmd.push(is.read_string()?);
                },
                186 => {
                    self.ext_mnt.push(is.read_message()?);
                },
                192 => {
                    self.manage_cgroups = ::std::option::Option::Some(is.read_bool()?);
                },
                202 => {
                    self.cg_root.push(is.read_message()?);
                },
                208 => {
                    self.rst_sibling = ::std::option::Option::Some(is.read_bool()?);
                },
                218 => {
                    self.inherit_fd.push(is.read_message()?);
                },
                224 => {
                    self.auto_ext_mnt = ::std::option::Option::Some(is.read_bool()?);
                },
                232 => {
                    self.ext_sharing = ::std::option::Option::Some(is.read_bool()?);
                },
                240 => {
                    self.ext_masters = ::std::option::Option::Some(is.read_bool()?);
                },
                250 => {
                    self.skip_mnt.push(is.read_string()?);
                },
                258 => {
                    self.enable_fs.push(is.read_string()?);
                },
                266 => {
                    self.unix_sk_ino.push(is.read_message()?);
                },
                272 => {
                    self.manage_cgroups_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                280 => {
                    self.ghost_limit = ::std::option::Option::Some(is.read_uint32()?);
                },
                290 => {
                    self.irmap_scan_paths.push(is.read_string()?);
                },
                298 => {
                    self.external.push(is.read_string()?);
                },
                304 => {
                    self.empty_ns = ::std::option::Option::Some(is.read_uint32()?);
                },
                314 => {
                    self.join_ns.push(is.read_message()?);
                },
                330 => {
                    self.cgroup_props = ::std::option::Option::Some(is.read_string()?);
                },
                338 => {
                    self.cgroup_props_file = ::std::option::Option::Some(is.read_string()?);
                },
                346 => {
                    self.cgroup_dump_controller.push(is.read_string()?);
                },
                354 => {
                    self.freeze_cgroup = ::std::option::Option::Some(is.read_string()?);
                },
                360 => {
                    self.timeout = ::std::option::Option::Some(is.read_uint32()?);
                },
                368 => {
                    self.tcp_skip_in_flight = ::std::option::Option::Some(is.read_bool()?);
                },
                376 => {
                    self.weak_sysctls = ::std::option::Option::Some(is.read_bool()?);
                },
                384 => {
                    self.lazy_pages = ::std::option::Option::Some(is.read_bool()?);
                },
                392 => {
                    self.status_fd = ::std::option::Option::Some(is.read_int32()?);
                },
                400 => {
                    self.orphan_pts_master = ::std::option::Option::Some(is.read_bool()?);
                },
                410 => {
                    self.config_file = ::std::option::Option::Some(is.read_string()?);
                },
                416 => {
                    self.tcp_close = ::std::option::Option::Some(is.read_bool()?);
                },
                426 => {
                    self.lsm_profile = ::std::option::Option::Some(is.read_string()?);
                },
                434 => {
                    self.tls_cacert = ::std::option::Option::Some(is.read_string()?);
                },
                442 => {
                    self.tls_cacrl = ::std::option::Option::Some(is.read_string()?);
                },
                450 => {
                    self.tls_cert = ::std::option::Option::Some(is.read_string()?);
                },
                458 => {
                    self.tls_key = ::std::option::Option::Some(is.read_string()?);
                },
                464 => {
                    self.tls = ::std::option::Option::Some(is.read_bool()?);
                },
                472 => {
                    self.tls_no_cn_verify = ::std::option::Option::Some(is.read_bool()?);
                },
                482 => {
                    self.cgroup_yard = ::std::option::Option::Some(is.read_string()?);
                },
                488 => {
                    self.pre_dump_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                496 => {
                    self.pidfd_store_sk = ::std::option::Option::Some(is.read_int32()?);
                },
                506 => {
                    self.lsm_mount_context = ::std::option::Option::Some(is.read_string()?);
                },
                512 => {
                    self.network_lock = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                520 => {
                    self.mntns_compat_mode = ::std::option::Option::Some(is.read_bool()?);
                },
                528 => {
                    self.skip_file_rwx_check = ::std::option::Option::Some(is.read_bool()?);
                },
                536 => {
                    self.unprivileged = ::std::option::Option::Some(is.read_bool()?);
                },
                552 => {
                    self.leave_stopped = ::std::option::Option::Some(is.read_bool()?);
                },
                560 => {
                    self.display_stats = ::std::option::Option::Some(is.read_bool()?);
                },
                568 => {
                    self.log_to_stderr = ::std::option::Option::Some(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 let Some(v) = self.images_dir_fd {
            my_size += ::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.images_dir.as_ref() {
            my_size += ::protobuf::rt::string_size(68, &v);
        }
        if let Some(v) = self.pid {
            my_size += ::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.leave_running {
            my_size += 1 + 1;
        }
        if let Some(v) = self.ext_unix_sk {
            my_size += 1 + 1;
        }
        if let Some(v) = self.tcp_established {
            my_size += 1 + 1;
        }
        if let Some(v) = self.evasive_devices {
            my_size += 1 + 1;
        }
        if let Some(v) = self.shell_job {
            my_size += 1 + 1;
        }
        if let Some(v) = self.file_locks {
            my_size += 1 + 1;
        }
        if let Some(v) = self.log_level {
            my_size += ::protobuf::rt::int32_size(9, v);
        }
        if let Some(v) = self.log_file.as_ref() {
            my_size += ::protobuf::rt::string_size(10, &v);
        }
        if let Some(v) = self.ps.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.notify_scripts {
            my_size += 1 + 1;
        }
        if let Some(v) = self.root.as_ref() {
            my_size += ::protobuf::rt::string_size(13, &v);
        }
        if let Some(v) = self.parent_img.as_ref() {
            my_size += ::protobuf::rt::string_size(14, &v);
        }
        if let Some(v) = self.track_mem {
            my_size += 1 + 1;
        }
        if let Some(v) = self.auto_dedup {
            my_size += 2 + 1;
        }
        if let Some(v) = self.work_dir_fd {
            my_size += ::protobuf::rt::int32_size(17, v);
        }
        if let Some(v) = self.link_remap {
            my_size += 2 + 1;
        }
        for value in &self.veths {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.cpu_cap {
            my_size += ::protobuf::rt::uint32_size(20, v);
        }
        if let Some(v) = self.force_irmap {
            my_size += 2 + 1;
        }
        for value in &self.exec_cmd {
            my_size += ::protobuf::rt::string_size(22, &value);
        };
        for value in &self.ext_mnt {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.manage_cgroups {
            my_size += 2 + 1;
        }
        for value in &self.cg_root {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.rst_sibling {
            my_size += 2 + 1;
        }
        for value in &self.inherit_fd {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.auto_ext_mnt {
            my_size += 2 + 1;
        }
        if let Some(v) = self.ext_sharing {
            my_size += 2 + 1;
        }
        if let Some(v) = self.ext_masters {
            my_size += 2 + 1;
        }
        for value in &self.skip_mnt {
            my_size += ::protobuf::rt::string_size(31, &value);
        };
        for value in &self.enable_fs {
            my_size += ::protobuf::rt::string_size(32, &value);
        };
        for value in &self.unix_sk_ino {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.manage_cgroups_mode {
            my_size += ::protobuf::rt::int32_size(34, v.value());
        }
        if let Some(v) = self.ghost_limit {
            my_size += ::protobuf::rt::uint32_size(35, v);
        }
        for value in &self.irmap_scan_paths {
            my_size += ::protobuf::rt::string_size(36, &value);
        };
        for value in &self.external {
            my_size += ::protobuf::rt::string_size(37, &value);
        };
        if let Some(v) = self.empty_ns {
            my_size += ::protobuf::rt::uint32_size(38, v);
        }
        for value in &self.join_ns {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.cgroup_props.as_ref() {
            my_size += ::protobuf::rt::string_size(41, &v);
        }
        if let Some(v) = self.cgroup_props_file.as_ref() {
            my_size += ::protobuf::rt::string_size(42, &v);
        }
        for value in &self.cgroup_dump_controller {
            my_size += ::protobuf::rt::string_size(43, &value);
        };
        if let Some(v) = self.freeze_cgroup.as_ref() {
            my_size += ::protobuf::rt::string_size(44, &v);
        }
        if let Some(v) = self.timeout {
            my_size += ::protobuf::rt::uint32_size(45, v);
        }
        if let Some(v) = self.tcp_skip_in_flight {
            my_size += 2 + 1;
        }
        if let Some(v) = self.weak_sysctls {
            my_size += 2 + 1;
        }
        if let Some(v) = self.lazy_pages {
            my_size += 2 + 1;
        }
        if let Some(v) = self.status_fd {
            my_size += ::protobuf::rt::int32_size(49, v);
        }
        if let Some(v) = self.orphan_pts_master {
            my_size += 2 + 1;
        }
        if let Some(v) = self.config_file.as_ref() {
            my_size += ::protobuf::rt::string_size(51, &v);
        }
        if let Some(v) = self.tcp_close {
            my_size += 2 + 1;
        }
        if let Some(v) = self.lsm_profile.as_ref() {
            my_size += ::protobuf::rt::string_size(53, &v);
        }
        if let Some(v) = self.tls_cacert.as_ref() {
            my_size += ::protobuf::rt::string_size(54, &v);
        }
        if let Some(v) = self.tls_cacrl.as_ref() {
            my_size += ::protobuf::rt::string_size(55, &v);
        }
        if let Some(v) = self.tls_cert.as_ref() {
            my_size += ::protobuf::rt::string_size(56, &v);
        }
        if let Some(v) = self.tls_key.as_ref() {
            my_size += ::protobuf::rt::string_size(57, &v);
        }
        if let Some(v) = self.tls {
            my_size += 2 + 1;
        }
        if let Some(v) = self.tls_no_cn_verify {
            my_size += 2 + 1;
        }
        if let Some(v) = self.cgroup_yard.as_ref() {
            my_size += ::protobuf::rt::string_size(60, &v);
        }
        if let Some(v) = self.pre_dump_mode {
            my_size += ::protobuf::rt::int32_size(61, v.value());
        }
        if let Some(v) = self.pidfd_store_sk {
            my_size += ::protobuf::rt::int32_size(62, v);
        }
        if let Some(v) = self.lsm_mount_context.as_ref() {
            my_size += ::protobuf::rt::string_size(63, &v);
        }
        if let Some(v) = self.network_lock {
            my_size += ::protobuf::rt::int32_size(64, v.value());
        }
        if let Some(v) = self.mntns_compat_mode {
            my_size += 2 + 1;
        }
        if let Some(v) = self.skip_file_rwx_check {
            my_size += 2 + 1;
        }
        if let Some(v) = self.unprivileged {
            my_size += 2 + 1;
        }
        if let Some(v) = self.leave_stopped {
            my_size += 2 + 1;
        }
        if let Some(v) = self.display_stats {
            my_size += 2 + 1;
        }
        if let Some(v) = self.log_to_stderr {
            my_size += 2 + 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 let Some(v) = self.images_dir_fd {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.images_dir.as_ref() {
            os.write_string(68, v)?;
        }
        if let Some(v) = self.pid {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.leave_running {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.ext_unix_sk {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.tcp_established {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.evasive_devices {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.shell_job {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.file_locks {
            os.write_bool(8, v)?;
        }
        if let Some(v) = self.log_level {
            os.write_int32(9, v)?;
        }
        if let Some(v) = self.log_file.as_ref() {
            os.write_string(10, v)?;
        }
        if let Some(v) = self.ps.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
        }
        if let Some(v) = self.notify_scripts {
            os.write_bool(12, v)?;
        }
        if let Some(v) = self.root.as_ref() {
            os.write_string(13, v)?;
        }
        if let Some(v) = self.parent_img.as_ref() {
            os.write_string(14, v)?;
        }
        if let Some(v) = self.track_mem {
            os.write_bool(15, v)?;
        }
        if let Some(v) = self.auto_dedup {
            os.write_bool(16, v)?;
        }
        if let Some(v) = self.work_dir_fd {
            os.write_int32(17, v)?;
        }
        if let Some(v) = self.link_remap {
            os.write_bool(18, v)?;
        }
        for v in &self.veths {
            ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
        };
        if let Some(v) = self.cpu_cap {
            os.write_uint32(20, v)?;
        }
        if let Some(v) = self.force_irmap {
            os.write_bool(21, v)?;
        }
        for v in &self.exec_cmd {
            os.write_string(22, &v)?;
        };
        for v in &self.ext_mnt {
            ::protobuf::rt::write_message_field_with_cached_size(23, v, os)?;
        };
        if let Some(v) = self.manage_cgroups {
            os.write_bool(24, v)?;
        }
        for v in &self.cg_root {
            ::protobuf::rt::write_message_field_with_cached_size(25, v, os)?;
        };
        if let Some(v) = self.rst_sibling {
            os.write_bool(26, v)?;
        }
        for v in &self.inherit_fd {
            ::protobuf::rt::write_message_field_with_cached_size(27, v, os)?;
        };
        if let Some(v) = self.auto_ext_mnt {
            os.write_bool(28, v)?;
        }
        if let Some(v) = self.ext_sharing {
            os.write_bool(29, v)?;
        }
        if let Some(v) = self.ext_masters {
            os.write_bool(30, v)?;
        }
        for v in &self.skip_mnt {
            os.write_string(31, &v)?;
        };
        for v in &self.enable_fs {
            os.write_string(32, &v)?;
        };
        for v in &self.unix_sk_ino {
            ::protobuf::rt::write_message_field_with_cached_size(33, v, os)?;
        };
        if let Some(v) = self.manage_cgroups_mode {
            os.write_enum(34, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.ghost_limit {
            os.write_uint32(35, v)?;
        }
        for v in &self.irmap_scan_paths {
            os.write_string(36, &v)?;
        };
        for v in &self.external {
            os.write_string(37, &v)?;
        };
        if let Some(v) = self.empty_ns {
            os.write_uint32(38, v)?;
        }
        for v in &self.join_ns {
            ::protobuf::rt::write_message_field_with_cached_size(39, v, os)?;
        };
        if let Some(v) = self.cgroup_props.as_ref() {
            os.write_string(41, v)?;
        }
        if let Some(v) = self.cgroup_props_file.as_ref() {
            os.write_string(42, v)?;
        }
        for v in &self.cgroup_dump_controller {
            os.write_string(43, &v)?;
        };
        if let Some(v) = self.freeze_cgroup.as_ref() {
            os.write_string(44, v)?;
        }
        if let Some(v) = self.timeout {
            os.write_uint32(45, v)?;
        }
        if let Some(v) = self.tcp_skip_in_flight {
            os.write_bool(46, v)?;
        }
        if let Some(v) = self.weak_sysctls {
            os.write_bool(47, v)?;
        }
        if let Some(v) = self.lazy_pages {
            os.write_bool(48, v)?;
        }
        if let Some(v) = self.status_fd {
            os.write_int32(49, v)?;
        }
        if let Some(v) = self.orphan_pts_master {
            os.write_bool(50, v)?;
        }
        if let Some(v) = self.config_file.as_ref() {
            os.write_string(51, v)?;
        }
        if let Some(v) = self.tcp_close {
            os.write_bool(52, v)?;
        }
        if let Some(v) = self.lsm_profile.as_ref() {
            os.write_string(53, v)?;
        }
        if let Some(v) = self.tls_cacert.as_ref() {
            os.write_string(54, v)?;
        }
        if let Some(v) = self.tls_cacrl.as_ref() {
            os.write_string(55, v)?;
        }
        if let Some(v) = self.tls_cert.as_ref() {
            os.write_string(56, v)?;
        }
        if let Some(v) = self.tls_key.as_ref() {
            os.write_string(57, v)?;
        }
        if let Some(v) = self.tls {
            os.write_bool(58, v)?;
        }
        if let Some(v) = self.tls_no_cn_verify {
            os.write_bool(59, v)?;
        }
        if let Some(v) = self.cgroup_yard.as_ref() {
            os.write_string(60, v)?;
        }
        if let Some(v) = self.pre_dump_mode {
            os.write_enum(61, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.pidfd_store_sk {
            os.write_int32(62, v)?;
        }
        if let Some(v) = self.lsm_mount_context.as_ref() {
            os.write_string(63, v)?;
        }
        if let Some(v) = self.network_lock {
            os.write_enum(64, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.mntns_compat_mode {
            os.write_bool(65, v)?;
        }
        if let Some(v) = self.skip_file_rwx_check {
            os.write_bool(66, v)?;
        }
        if let Some(v) = self.unprivileged {
            os.write_bool(67, v)?;
        }
        if let Some(v) = self.leave_stopped {
            os.write_bool(69, v)?;
        }
        if let Some(v) = self.display_stats {
            os.write_bool(70, v)?;
        }
        if let Some(v) = self.log_to_stderr {
            os.write_bool(71, v)?;
        }
        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() -> Criu_opts {
        Criu_opts::new()
    }

    fn clear(&mut self) {
        self.images_dir_fd = ::std::option::Option::None;
        self.images_dir = ::std::option::Option::None;
        self.pid = ::std::option::Option::None;
        self.leave_running = ::std::option::Option::None;
        self.ext_unix_sk = ::std::option::Option::None;
        self.tcp_established = ::std::option::Option::None;
        self.evasive_devices = ::std::option::Option::None;
        self.shell_job = ::std::option::Option::None;
        self.file_locks = ::std::option::Option::None;
        self.log_level = ::std::option::Option::None;
        self.log_file = ::std::option::Option::None;
        self.ps.clear();
        self.notify_scripts = ::std::option::Option::None;
        self.root = ::std::option::Option::None;
        self.parent_img = ::std::option::Option::None;
        self.track_mem = ::std::option::Option::None;
        self.auto_dedup = ::std::option::Option::None;
        self.work_dir_fd = ::std::option::Option::None;
        self.link_remap = ::std::option::Option::None;
        self.veths.clear();
        self.cpu_cap = ::std::option::Option::None;
        self.force_irmap = ::std::option::Option::None;
        self.exec_cmd.clear();
        self.ext_mnt.clear();
        self.manage_cgroups = ::std::option::Option::None;
        self.cg_root.clear();
        self.rst_sibling = ::std::option::Option::None;
        self.inherit_fd.clear();
        self.auto_ext_mnt = ::std::option::Option::None;
        self.ext_sharing = ::std::option::Option::None;
        self.ext_masters = ::std::option::Option::None;
        self.skip_mnt.clear();
        self.enable_fs.clear();
        self.unix_sk_ino.clear();
        self.manage_cgroups_mode = ::std::option::Option::None;
        self.ghost_limit = ::std::option::Option::None;
        self.irmap_scan_paths.clear();
        self.external.clear();
        self.empty_ns = ::std::option::Option::None;
        self.join_ns.clear();
        self.cgroup_props = ::std::option::Option::None;
        self.cgroup_props_file = ::std::option::Option::None;
        self.cgroup_dump_controller.clear();
        self.freeze_cgroup = ::std::option::Option::None;
        self.timeout = ::std::option::Option::None;
        self.tcp_skip_in_flight = ::std::option::Option::None;
        self.weak_sysctls = ::std::option::Option::None;
        self.lazy_pages = ::std::option::Option::None;
        self.status_fd = ::std::option::Option::None;
        self.orphan_pts_master = ::std::option::Option::None;
        self.config_file = ::std::option::Option::None;
        self.tcp_close = ::std::option::Option::None;
        self.lsm_profile = ::std::option::Option::None;
        self.tls_cacert = ::std::option::Option::None;
        self.tls_cacrl = ::std::option::Option::None;
        self.tls_cert = ::std::option::Option::None;
        self.tls_key = ::std::option::Option::None;
        self.tls = ::std::option::Option::None;
        self.tls_no_cn_verify = ::std::option::Option::None;
        self.cgroup_yard = ::std::option::Option::None;
        self.pre_dump_mode = ::std::option::Option::None;
        self.pidfd_store_sk = ::std::option::Option::None;
        self.lsm_mount_context = ::std::option::Option::None;
        self.network_lock = ::std::option::Option::None;
        self.mntns_compat_mode = ::std::option::Option::None;
        self.skip_file_rwx_check = ::std::option::Option::None;
        self.unprivileged = ::std::option::Option::None;
        self.leave_stopped = ::std::option::Option::None;
        self.display_stats = ::std::option::Option::None;
        self.log_to_stderr = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Criu_opts {
        static instance: Criu_opts = Criu_opts {
            images_dir_fd: ::std::option::Option::None,
            images_dir: ::std::option::Option::None,
            pid: ::std::option::Option::None,
            leave_running: ::std::option::Option::None,
            ext_unix_sk: ::std::option::Option::None,
            tcp_established: ::std::option::Option::None,
            evasive_devices: ::std::option::Option::None,
            shell_job: ::std::option::Option::None,
            file_locks: ::std::option::Option::None,
            log_level: ::std::option::Option::None,
            log_file: ::std::option::Option::None,
            ps: ::protobuf::MessageField::none(),
            notify_scripts: ::std::option::Option::None,
            root: ::std::option::Option::None,
            parent_img: ::std::option::Option::None,
            track_mem: ::std::option::Option::None,
            auto_dedup: ::std::option::Option::None,
            work_dir_fd: ::std::option::Option::None,
            link_remap: ::std::option::Option::None,
            veths: ::std::vec::Vec::new(),
            cpu_cap: ::std::option::Option::None,
            force_irmap: ::std::option::Option::None,
            exec_cmd: ::std::vec::Vec::new(),
            ext_mnt: ::std::vec::Vec::new(),
            manage_cgroups: ::std::option::Option::None,
            cg_root: ::std::vec::Vec::new(),
            rst_sibling: ::std::option::Option::None,
            inherit_fd: ::std::vec::Vec::new(),
            auto_ext_mnt: ::std::option::Option::None,
            ext_sharing: ::std::option::Option::None,
            ext_masters: ::std::option::Option::None,
            skip_mnt: ::std::vec::Vec::new(),
            enable_fs: ::std::vec::Vec::new(),
            unix_sk_ino: ::std::vec::Vec::new(),
            manage_cgroups_mode: ::std::option::Option::None,
            ghost_limit: ::std::option::Option::None,
            irmap_scan_paths: ::std::vec::Vec::new(),
            external: ::std::vec::Vec::new(),
            empty_ns: ::std::option::Option::None,
            join_ns: ::std::vec::Vec::new(),
            cgroup_props: ::std::option::Option::None,
            cgroup_props_file: ::std::option::Option::None,
            cgroup_dump_controller: ::std::vec::Vec::new(),
            freeze_cgroup: ::std::option::Option::None,
            timeout: ::std::option::Option::None,
            tcp_skip_in_flight: ::std::option::Option::None,
            weak_sysctls: ::std::option::Option::None,
            lazy_pages: ::std::option::Option::None,
            status_fd: ::std::option::Option::None,
            orphan_pts_master: ::std::option::Option::None,
            config_file: ::std::option::Option::None,
            tcp_close: ::std::option::Option::None,
            lsm_profile: ::std::option::Option::None,
            tls_cacert: ::std::option::Option::None,
            tls_cacrl: ::std::option::Option::None,
            tls_cert: ::std::option::Option::None,
            tls_key: ::std::option::Option::None,
            tls: ::std::option::Option::None,
            tls_no_cn_verify: ::std::option::Option::None,
            cgroup_yard: ::std::option::Option::None,
            pre_dump_mode: ::std::option::Option::None,
            pidfd_store_sk: ::std::option::Option::None,
            lsm_mount_context: ::std::option::Option::None,
            network_lock: ::std::option::Option::None,
            mntns_compat_mode: ::std::option::Option::None,
            skip_file_rwx_check: ::std::option::Option::None,
            unprivileged: ::std::option::Option::None,
            leave_stopped: ::std::option::Option::None,
            display_stats: ::std::option::Option::None,
            log_to_stderr: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Criu_opts {
    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("criu_opts").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_dump_resp)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_dump_resp {
    // message fields
    // @@protoc_insertion_point(field:criu_dump_resp.restored)
    pub restored: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_dump_resp.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional bool restored = 1;

    pub fn restored(&self) -> bool {
        self.restored.unwrap_or(false)
    }

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

    pub fn has_restored(&self) -> bool {
        self.restored.is_some()
    }

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

    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_option_accessor::<_, _>(
            "restored",
            |m: &Criu_dump_resp| { &m.restored },
            |m: &mut Criu_dump_resp| { &mut m.restored },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_dump_resp>(
            "criu_dump_resp",
            fields,
            oneofs,
        )
    }
}

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

    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.restored = ::std::option::Option::Some(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 let Some(v) = self.restored {
            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 let Some(v) = self.restored {
            os.write_bool(1, v)?;
        }
        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() -> Criu_dump_resp {
        Criu_dump_resp::new()
    }

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

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

impl ::protobuf::MessageFull for Criu_dump_resp {
    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("criu_dump_resp").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_restore_resp)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_restore_resp {
    // message fields
    // @@protoc_insertion_point(field:criu_restore_resp.pid)
    pub pid: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_restore_resp.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required int32 pid = 1;

    pub fn pid(&self) -> i32 {
        self.pid.unwrap_or(0)
    }

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

    pub fn has_pid(&self) -> bool {
        self.pid.is_some()
    }

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

    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_option_accessor::<_, _>(
            "pid",
            |m: &Criu_restore_resp| { &m.pid },
            |m: &mut Criu_restore_resp| { &mut m.pid },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_restore_resp>(
            "criu_restore_resp",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.pid.is_none() {
            return false;
        }
        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.pid = ::std::option::Option::Some(is.read_int32()?);
                },
                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 Some(v) = self.pid {
            my_size += ::protobuf::rt::int32_size(1, v);
        }
        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 Some(v) = self.pid {
            os.write_int32(1, v)?;
        }
        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() -> Criu_restore_resp {
        Criu_restore_resp::new()
    }

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

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

impl ::protobuf::MessageFull for Criu_restore_resp {
    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("criu_restore_resp").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_notify)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_notify {
    // message fields
    // @@protoc_insertion_point(field:criu_notify.script)
    pub script: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_notify.pid)
    pub pid: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_notify.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional string script = 1;

    pub fn script(&self) -> &str {
        match self.script.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_script(&self) -> bool {
        self.script.is_some()
    }

    // Param is passed by value, moved
    pub fn set_script(&mut self, v: ::std::string::String) {
        self.script = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_script(&mut self) -> &mut ::std::string::String {
        if self.script.is_none() {
            self.script = ::std::option::Option::Some(::std::string::String::new());
        }
        self.script.as_mut().unwrap()
    }

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

    // optional int32 pid = 2;

    pub fn pid(&self) -> i32 {
        self.pid.unwrap_or(0)
    }

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

    pub fn has_pid(&self) -> bool {
        self.pid.is_some()
    }

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

    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_option_accessor::<_, _>(
            "script",
            |m: &Criu_notify| { &m.script },
            |m: &mut Criu_notify| { &mut m.script },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pid",
            |m: &Criu_notify| { &m.pid },
            |m: &mut Criu_notify| { &mut m.pid },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_notify>(
            "criu_notify",
            fields,
            oneofs,
        )
    }
}

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

    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.script = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.pid = ::std::option::Option::Some(is.read_int32()?);
                },
                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 Some(v) = self.script.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.pid {
            my_size += ::protobuf::rt::int32_size(2, v);
        }
        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 Some(v) = self.script.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.pid {
            os.write_int32(2, v)?;
        }
        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() -> Criu_notify {
        Criu_notify::new()
    }

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

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

impl ::protobuf::MessageFull for Criu_notify {
    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("criu_notify").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_features)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_features {
    // message fields
    // @@protoc_insertion_point(field:criu_features.mem_track)
    pub mem_track: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_features.lazy_pages)
    pub lazy_pages: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_features.pidfd_store)
    pub pidfd_store: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_features.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional bool mem_track = 1;

    pub fn mem_track(&self) -> bool {
        self.mem_track.unwrap_or(false)
    }

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

    pub fn has_mem_track(&self) -> bool {
        self.mem_track.is_some()
    }

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

    // optional bool lazy_pages = 2;

    pub fn lazy_pages(&self) -> bool {
        self.lazy_pages.unwrap_or(false)
    }

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

    pub fn has_lazy_pages(&self) -> bool {
        self.lazy_pages.is_some()
    }

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

    // optional bool pidfd_store = 3;

    pub fn pidfd_store(&self) -> bool {
        self.pidfd_store.unwrap_or(false)
    }

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

    pub fn has_pidfd_store(&self) -> bool {
        self.pidfd_store.is_some()
    }

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

    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_option_accessor::<_, _>(
            "mem_track",
            |m: &Criu_features| { &m.mem_track },
            |m: &mut Criu_features| { &mut m.mem_track },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "lazy_pages",
            |m: &Criu_features| { &m.lazy_pages },
            |m: &mut Criu_features| { &mut m.lazy_pages },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pidfd_store",
            |m: &Criu_features| { &m.pidfd_store },
            |m: &mut Criu_features| { &mut m.pidfd_store },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_features>(
            "criu_features",
            fields,
            oneofs,
        )
    }
}

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

    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.mem_track = ::std::option::Option::Some(is.read_bool()?);
                },
                16 => {
                    self.lazy_pages = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.pidfd_store = ::std::option::Option::Some(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 let Some(v) = self.mem_track {
            my_size += 1 + 1;
        }
        if let Some(v) = self.lazy_pages {
            my_size += 1 + 1;
        }
        if let Some(v) = self.pidfd_store {
            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 let Some(v) = self.mem_track {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.lazy_pages {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.pidfd_store {
            os.write_bool(3, v)?;
        }
        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() -> Criu_features {
        Criu_features::new()
    }

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

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

impl ::protobuf::MessageFull for Criu_features {
    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("criu_features").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_req)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_req {
    // message fields
    // @@protoc_insertion_point(field:criu_req.type)
    pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_req_type>>,
    // @@protoc_insertion_point(field:criu_req.opts)
    pub opts: ::protobuf::MessageField<Criu_opts>,
    // @@protoc_insertion_point(field:criu_req.notify_success)
    pub notify_success: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_req.keep_open)
    pub keep_open: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_req.features)
    pub features: ::protobuf::MessageField<Criu_features>,
    // @@protoc_insertion_point(field:criu_req.pid)
    pub pid: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_req.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required .criu_req_type type = 1;

    pub fn type_(&self) -> Criu_req_type {
        match self.type_ {
            Some(e) => e.enum_value_or(Criu_req_type::EMPTY),
            None => Criu_req_type::EMPTY,
        }
    }

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

    pub fn has_type(&self) -> bool {
        self.type_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type(&mut self, v: Criu_req_type) {
        self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    // optional bool notify_success = 3;

    pub fn notify_success(&self) -> bool {
        self.notify_success.unwrap_or(false)
    }

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

    pub fn has_notify_success(&self) -> bool {
        self.notify_success.is_some()
    }

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

    // optional bool keep_open = 4;

    pub fn keep_open(&self) -> bool {
        self.keep_open.unwrap_or(false)
    }

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

    pub fn has_keep_open(&self) -> bool {
        self.keep_open.is_some()
    }

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

    // optional uint32 pid = 6;

    pub fn pid(&self) -> u32 {
        self.pid.unwrap_or(0)
    }

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

    pub fn has_pid(&self) -> bool {
        self.pid.is_some()
    }

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "type",
            |m: &Criu_req| { &m.type_ },
            |m: &mut Criu_req| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_opts>(
            "opts",
            |m: &Criu_req| { &m.opts },
            |m: &mut Criu_req| { &mut m.opts },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "notify_success",
            |m: &Criu_req| { &m.notify_success },
            |m: &mut Criu_req| { &mut m.notify_success },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "keep_open",
            |m: &Criu_req| { &m.keep_open },
            |m: &mut Criu_req| { &mut m.keep_open },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_features>(
            "features",
            |m: &Criu_req| { &m.features },
            |m: &mut Criu_req| { &mut m.features },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "pid",
            |m: &Criu_req| { &m.pid },
            |m: &mut Criu_req| { &mut m.pid },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_req>(
            "criu_req",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.type_.is_none() {
            return false;
        }
        for v in &self.opts {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.features {
            if !v.is_initialized() {
                return false;
            }
        };
        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.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.opts)?;
                },
                24 => {
                    self.notify_success = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.keep_open = ::std::option::Option::Some(is.read_bool()?);
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.features)?;
                },
                48 => {
                    self.pid = ::std::option::Option::Some(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 let Some(v) = self.type_ {
            my_size += ::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.opts.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.notify_success {
            my_size += 1 + 1;
        }
        if let Some(v) = self.keep_open {
            my_size += 1 + 1;
        }
        if let Some(v) = self.features.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.pid {
            my_size += ::protobuf::rt::uint32_size(6, v);
        }
        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 Some(v) = self.type_ {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.opts.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.notify_success {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.keep_open {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.features.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if let Some(v) = self.pid {
            os.write_uint32(6, v)?;
        }
        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() -> Criu_req {
        Criu_req::new()
    }

    fn clear(&mut self) {
        self.type_ = ::std::option::Option::None;
        self.opts.clear();
        self.notify_success = ::std::option::Option::None;
        self.keep_open = ::std::option::Option::None;
        self.features.clear();
        self.pid = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Criu_req {
        static instance: Criu_req = Criu_req {
            type_: ::std::option::Option::None,
            opts: ::protobuf::MessageField::none(),
            notify_success: ::std::option::Option::None,
            keep_open: ::std::option::Option::None,
            features: ::protobuf::MessageField::none(),
            pid: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Criu_req {
    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("criu_req").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_resp)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_resp {
    // message fields
    // @@protoc_insertion_point(field:criu_resp.type)
    pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_req_type>>,
    // @@protoc_insertion_point(field:criu_resp.success)
    pub success: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:criu_resp.dump)
    pub dump: ::protobuf::MessageField<Criu_dump_resp>,
    // @@protoc_insertion_point(field:criu_resp.restore)
    pub restore: ::protobuf::MessageField<Criu_restore_resp>,
    // @@protoc_insertion_point(field:criu_resp.notify)
    pub notify: ::protobuf::MessageField<Criu_notify>,
    // @@protoc_insertion_point(field:criu_resp.ps)
    pub ps: ::protobuf::MessageField<Criu_page_server_info>,
    // @@protoc_insertion_point(field:criu_resp.cr_errno)
    pub cr_errno: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_resp.features)
    pub features: ::protobuf::MessageField<Criu_features>,
    // @@protoc_insertion_point(field:criu_resp.cr_errmsg)
    pub cr_errmsg: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_resp.version)
    pub version: ::protobuf::MessageField<Criu_version>,
    // @@protoc_insertion_point(field:criu_resp.status)
    pub status: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_resp.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required .criu_req_type type = 1;

    pub fn type_(&self) -> Criu_req_type {
        match self.type_ {
            Some(e) => e.enum_value_or(Criu_req_type::EMPTY),
            None => Criu_req_type::EMPTY,
        }
    }

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

    pub fn has_type(&self) -> bool {
        self.type_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type(&mut self, v: Criu_req_type) {
        self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
    }

    // required bool success = 2;

    pub fn success(&self) -> bool {
        self.success.unwrap_or(false)
    }

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

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

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

    // optional int32 cr_errno = 7;

    pub fn cr_errno(&self) -> i32 {
        self.cr_errno.unwrap_or(0)
    }

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

    pub fn has_cr_errno(&self) -> bool {
        self.cr_errno.is_some()
    }

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

    // optional string cr_errmsg = 9;

    pub fn cr_errmsg(&self) -> &str {
        match self.cr_errmsg.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_cr_errmsg(&self) -> bool {
        self.cr_errmsg.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cr_errmsg(&mut self, v: ::std::string::String) {
        self.cr_errmsg = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_cr_errmsg(&mut self) -> &mut ::std::string::String {
        if self.cr_errmsg.is_none() {
            self.cr_errmsg = ::std::option::Option::Some(::std::string::String::new());
        }
        self.cr_errmsg.as_mut().unwrap()
    }

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

    // optional int32 status = 11;

    pub fn status(&self) -> i32 {
        self.status.unwrap_or(0)
    }

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

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(11);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "type",
            |m: &Criu_resp| { &m.type_ },
            |m: &mut Criu_resp| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "success",
            |m: &Criu_resp| { &m.success },
            |m: &mut Criu_resp| { &mut m.success },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_dump_resp>(
            "dump",
            |m: &Criu_resp| { &m.dump },
            |m: &mut Criu_resp| { &mut m.dump },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_restore_resp>(
            "restore",
            |m: &Criu_resp| { &m.restore },
            |m: &mut Criu_resp| { &mut m.restore },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_notify>(
            "notify",
            |m: &Criu_resp| { &m.notify },
            |m: &mut Criu_resp| { &mut m.notify },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_page_server_info>(
            "ps",
            |m: &Criu_resp| { &m.ps },
            |m: &mut Criu_resp| { &mut m.ps },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "cr_errno",
            |m: &Criu_resp| { &m.cr_errno },
            |m: &mut Criu_resp| { &mut m.cr_errno },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_features>(
            "features",
            |m: &Criu_resp| { &m.features },
            |m: &mut Criu_resp| { &mut m.features },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "cr_errmsg",
            |m: &Criu_resp| { &m.cr_errmsg },
            |m: &mut Criu_resp| { &mut m.cr_errmsg },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_version>(
            "version",
            |m: &Criu_resp| { &m.version },
            |m: &mut Criu_resp| { &mut m.version },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "status",
            |m: &Criu_resp| { &m.status },
            |m: &mut Criu_resp| { &mut m.status },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_resp>(
            "criu_resp",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.type_.is_none() {
            return false;
        }
        if self.success.is_none() {
            return false;
        }
        for v in &self.dump {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.restore {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.notify {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.ps {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.features {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.version {
            if !v.is_initialized() {
                return false;
            }
        };
        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.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                16 => {
                    self.success = ::std::option::Option::Some(is.read_bool()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.dump)?;
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.restore)?;
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.notify)?;
                },
                50 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.ps)?;
                },
                56 => {
                    self.cr_errno = ::std::option::Option::Some(is.read_int32()?);
                },
                66 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.features)?;
                },
                74 => {
                    self.cr_errmsg = ::std::option::Option::Some(is.read_string()?);
                },
                82 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.version)?;
                },
                88 => {
                    self.status = ::std::option::Option::Some(is.read_int32()?);
                },
                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 Some(v) = self.type_ {
            my_size += ::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.success {
            my_size += 1 + 1;
        }
        if let Some(v) = self.dump.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.restore.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.notify.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.ps.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.cr_errno {
            my_size += ::protobuf::rt::int32_size(7, v);
        }
        if let Some(v) = self.features.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.cr_errmsg.as_ref() {
            my_size += ::protobuf::rt::string_size(9, &v);
        }
        if let Some(v) = self.version.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.status {
            my_size += ::protobuf::rt::int32_size(11, v);
        }
        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 Some(v) = self.type_ {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.success {
            os.write_bool(2, v)?;
        }
        if let Some(v) = self.dump.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if let Some(v) = self.restore.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        if let Some(v) = self.notify.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if let Some(v) = self.ps.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        }
        if let Some(v) = self.cr_errno {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.features.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
        }
        if let Some(v) = self.cr_errmsg.as_ref() {
            os.write_string(9, v)?;
        }
        if let Some(v) = self.version.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        }
        if let Some(v) = self.status {
            os.write_int32(11, v)?;
        }
        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() -> Criu_resp {
        Criu_resp::new()
    }

    fn clear(&mut self) {
        self.type_ = ::std::option::Option::None;
        self.success = ::std::option::Option::None;
        self.dump.clear();
        self.restore.clear();
        self.notify.clear();
        self.ps.clear();
        self.cr_errno = ::std::option::Option::None;
        self.features.clear();
        self.cr_errmsg = ::std::option::Option::None;
        self.version.clear();
        self.status = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Criu_resp {
        static instance: Criu_resp = Criu_resp {
            type_: ::std::option::Option::None,
            success: ::std::option::Option::None,
            dump: ::protobuf::MessageField::none(),
            restore: ::protobuf::MessageField::none(),
            notify: ::protobuf::MessageField::none(),
            ps: ::protobuf::MessageField::none(),
            cr_errno: ::std::option::Option::None,
            features: ::protobuf::MessageField::none(),
            cr_errmsg: ::std::option::Option::None,
            version: ::protobuf::MessageField::none(),
            status: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Criu_resp {
    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("criu_resp").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:criu_version)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_version {
    // message fields
    // @@protoc_insertion_point(field:criu_version.major_number)
    pub major_number: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_version.minor_number)
    pub minor_number: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_version.gitid)
    pub gitid: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:criu_version.sublevel)
    pub sublevel: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_version.extra)
    pub extra: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:criu_version.name)
    pub name: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:criu_version.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required int32 major_number = 1;

    pub fn major_number(&self) -> i32 {
        self.major_number.unwrap_or(0)
    }

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

    pub fn has_major_number(&self) -> bool {
        self.major_number.is_some()
    }

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

    // required int32 minor_number = 2;

    pub fn minor_number(&self) -> i32 {
        self.minor_number.unwrap_or(0)
    }

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

    pub fn has_minor_number(&self) -> bool {
        self.minor_number.is_some()
    }

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

    // optional string gitid = 3;

    pub fn gitid(&self) -> &str {
        match self.gitid.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

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

    pub fn has_gitid(&self) -> bool {
        self.gitid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_gitid(&mut self, v: ::std::string::String) {
        self.gitid = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_gitid(&mut self) -> &mut ::std::string::String {
        if self.gitid.is_none() {
            self.gitid = ::std::option::Option::Some(::std::string::String::new());
        }
        self.gitid.as_mut().unwrap()
    }

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

    // optional int32 sublevel = 4;

    pub fn sublevel(&self) -> i32 {
        self.sublevel.unwrap_or(0)
    }

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

    pub fn has_sublevel(&self) -> bool {
        self.sublevel.is_some()
    }

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

    // optional int32 extra = 5;

    pub fn extra(&self) -> i32 {
        self.extra.unwrap_or(0)
    }

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

    pub fn has_extra(&self) -> bool {
        self.extra.is_some()
    }

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

    // optional string name = 6;

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

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

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

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

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "major_number",
            |m: &Criu_version| { &m.major_number },
            |m: &mut Criu_version| { &mut m.major_number },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "minor_number",
            |m: &Criu_version| { &m.minor_number },
            |m: &mut Criu_version| { &mut m.minor_number },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "gitid",
            |m: &Criu_version| { &m.gitid },
            |m: &mut Criu_version| { &mut m.gitid },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "sublevel",
            |m: &Criu_version| { &m.sublevel },
            |m: &mut Criu_version| { &mut m.sublevel },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "extra",
            |m: &Criu_version| { &m.extra },
            |m: &mut Criu_version| { &mut m.extra },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Criu_version| { &m.name },
            |m: &mut Criu_version| { &mut m.name },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Criu_version>(
            "criu_version",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.major_number.is_none() {
            return false;
        }
        if self.minor_number.is_none() {
            return false;
        }
        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.major_number = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.minor_number = ::std::option::Option::Some(is.read_int32()?);
                },
                26 => {
                    self.gitid = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.sublevel = ::std::option::Option::Some(is.read_int32()?);
                },
                40 => {
                    self.extra = ::std::option::Option::Some(is.read_int32()?);
                },
                50 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                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 Some(v) = self.major_number {
            my_size += ::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.minor_number {
            my_size += ::protobuf::rt::int32_size(2, v);
        }
        if let Some(v) = self.gitid.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.sublevel {
            my_size += ::protobuf::rt::int32_size(4, v);
        }
        if let Some(v) = self.extra {
            my_size += ::protobuf::rt::int32_size(5, v);
        }
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(6, &v);
        }
        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 Some(v) = self.major_number {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.minor_number {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.gitid.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.sublevel {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.extra {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.name.as_ref() {
            os.write_string(6, v)?;
        }
        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() -> Criu_version {
        Criu_version::new()
    }

    fn clear(&mut self) {
        self.major_number = ::std::option::Option::None;
        self.minor_number = ::std::option::Option::None;
        self.gitid = ::std::option::Option::None;
        self.sublevel = ::std::option::Option::None;
        self.extra = ::std::option::Option::None;
        self.name = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Criu_version {
        static instance: Criu_version = Criu_version {
            major_number: ::std::option::Option::None,
            minor_number: ::std::option::Option::None,
            gitid: ::std::option::Option::None,
            sublevel: ::std::option::Option::None,
            extra: ::std::option::Option::None,
            name: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Criu_version {
    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("criu_version").unwrap()).clone()
    }
}

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

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

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:criu_cg_mode)
pub enum Criu_cg_mode {
    // @@protoc_insertion_point(enum_value:criu_cg_mode.IGNORE)
    IGNORE = 0,
    // @@protoc_insertion_point(enum_value:criu_cg_mode.CG_NONE)
    CG_NONE = 1,
    // @@protoc_insertion_point(enum_value:criu_cg_mode.PROPS)
    PROPS = 2,
    // @@protoc_insertion_point(enum_value:criu_cg_mode.SOFT)
    SOFT = 3,
    // @@protoc_insertion_point(enum_value:criu_cg_mode.FULL)
    FULL = 4,
    // @@protoc_insertion_point(enum_value:criu_cg_mode.STRICT)
    STRICT = 5,
    // @@protoc_insertion_point(enum_value:criu_cg_mode.DEFAULT)
    DEFAULT = 6,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<Criu_cg_mode> {
        match value {
            0 => ::std::option::Option::Some(Criu_cg_mode::IGNORE),
            1 => ::std::option::Option::Some(Criu_cg_mode::CG_NONE),
            2 => ::std::option::Option::Some(Criu_cg_mode::PROPS),
            3 => ::std::option::Option::Some(Criu_cg_mode::SOFT),
            4 => ::std::option::Option::Some(Criu_cg_mode::FULL),
            5 => ::std::option::Option::Some(Criu_cg_mode::STRICT),
            6 => ::std::option::Option::Some(Criu_cg_mode::DEFAULT),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<Criu_cg_mode> {
        match str {
            "IGNORE" => ::std::option::Option::Some(Criu_cg_mode::IGNORE),
            "CG_NONE" => ::std::option::Option::Some(Criu_cg_mode::CG_NONE),
            "PROPS" => ::std::option::Option::Some(Criu_cg_mode::PROPS),
            "SOFT" => ::std::option::Option::Some(Criu_cg_mode::SOFT),
            "FULL" => ::std::option::Option::Some(Criu_cg_mode::FULL),
            "STRICT" => ::std::option::Option::Some(Criu_cg_mode::STRICT),
            "DEFAULT" => ::std::option::Option::Some(Criu_cg_mode::DEFAULT),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [Criu_cg_mode] = &[
        Criu_cg_mode::IGNORE,
        Criu_cg_mode::CG_NONE,
        Criu_cg_mode::PROPS,
        Criu_cg_mode::SOFT,
        Criu_cg_mode::FULL,
        Criu_cg_mode::STRICT,
        Criu_cg_mode::DEFAULT,
    ];
}

impl ::protobuf::EnumFull for Criu_cg_mode {
    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("criu_cg_mode").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 Criu_cg_mode {
    fn default() -> Self {
        Criu_cg_mode::IGNORE
    }
}

impl Criu_cg_mode {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Criu_cg_mode>("criu_cg_mode")
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:criu_network_lock_method)
pub enum Criu_network_lock_method {
    // @@protoc_insertion_point(enum_value:criu_network_lock_method.IPTABLES)
    IPTABLES = 1,
    // @@protoc_insertion_point(enum_value:criu_network_lock_method.NFTABLES)
    NFTABLES = 2,
    // @@protoc_insertion_point(enum_value:criu_network_lock_method.SKIP)
    SKIP = 3,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<Criu_network_lock_method> {
        match value {
            1 => ::std::option::Option::Some(Criu_network_lock_method::IPTABLES),
            2 => ::std::option::Option::Some(Criu_network_lock_method::NFTABLES),
            3 => ::std::option::Option::Some(Criu_network_lock_method::SKIP),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<Criu_network_lock_method> {
        match str {
            "IPTABLES" => ::std::option::Option::Some(Criu_network_lock_method::IPTABLES),
            "NFTABLES" => ::std::option::Option::Some(Criu_network_lock_method::NFTABLES),
            "SKIP" => ::std::option::Option::Some(Criu_network_lock_method::SKIP),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [Criu_network_lock_method] = &[
        Criu_network_lock_method::IPTABLES,
        Criu_network_lock_method::NFTABLES,
        Criu_network_lock_method::SKIP,
    ];
}

impl ::protobuf::EnumFull for Criu_network_lock_method {
    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("criu_network_lock_method").unwrap()).clone()
    }

    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
        let index = match self {
            Criu_network_lock_method::IPTABLES => 0,
            Criu_network_lock_method::NFTABLES => 1,
            Criu_network_lock_method::SKIP => 2,
        };
        Self::enum_descriptor().value_by_index(index)
    }
}

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

impl Criu_network_lock_method {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Criu_network_lock_method>("criu_network_lock_method")
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:criu_pre_dump_mode)
pub enum Criu_pre_dump_mode {
    // @@protoc_insertion_point(enum_value:criu_pre_dump_mode.SPLICE)
    SPLICE = 1,
    // @@protoc_insertion_point(enum_value:criu_pre_dump_mode.VM_READ)
    VM_READ = 2,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<Criu_pre_dump_mode> {
        match value {
            1 => ::std::option::Option::Some(Criu_pre_dump_mode::SPLICE),
            2 => ::std::option::Option::Some(Criu_pre_dump_mode::VM_READ),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<Criu_pre_dump_mode> {
        match str {
            "SPLICE" => ::std::option::Option::Some(Criu_pre_dump_mode::SPLICE),
            "VM_READ" => ::std::option::Option::Some(Criu_pre_dump_mode::VM_READ),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [Criu_pre_dump_mode] = &[
        Criu_pre_dump_mode::SPLICE,
        Criu_pre_dump_mode::VM_READ,
    ];
}

impl ::protobuf::EnumFull for Criu_pre_dump_mode {
    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("criu_pre_dump_mode").unwrap()).clone()
    }

    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
        let index = match self {
            Criu_pre_dump_mode::SPLICE => 0,
            Criu_pre_dump_mode::VM_READ => 1,
        };
        Self::enum_descriptor().value_by_index(index)
    }
}

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

impl Criu_pre_dump_mode {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Criu_pre_dump_mode>("criu_pre_dump_mode")
    }
}

#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
// @@protoc_insertion_point(enum:criu_req_type)
pub enum Criu_req_type {
    // @@protoc_insertion_point(enum_value:criu_req_type.EMPTY)
    EMPTY = 0,
    // @@protoc_insertion_point(enum_value:criu_req_type.DUMP)
    DUMP = 1,
    // @@protoc_insertion_point(enum_value:criu_req_type.RESTORE)
    RESTORE = 2,
    // @@protoc_insertion_point(enum_value:criu_req_type.CHECK)
    CHECK = 3,
    // @@protoc_insertion_point(enum_value:criu_req_type.PRE_DUMP)
    PRE_DUMP = 4,
    // @@protoc_insertion_point(enum_value:criu_req_type.PAGE_SERVER)
    PAGE_SERVER = 5,
    // @@protoc_insertion_point(enum_value:criu_req_type.NOTIFY)
    NOTIFY = 6,
    // @@protoc_insertion_point(enum_value:criu_req_type.CPUINFO_DUMP)
    CPUINFO_DUMP = 7,
    // @@protoc_insertion_point(enum_value:criu_req_type.CPUINFO_CHECK)
    CPUINFO_CHECK = 8,
    // @@protoc_insertion_point(enum_value:criu_req_type.FEATURE_CHECK)
    FEATURE_CHECK = 9,
    // @@protoc_insertion_point(enum_value:criu_req_type.VERSION)
    VERSION = 10,
    // @@protoc_insertion_point(enum_value:criu_req_type.WAIT_PID)
    WAIT_PID = 11,
    // @@protoc_insertion_point(enum_value:criu_req_type.PAGE_SERVER_CHLD)
    PAGE_SERVER_CHLD = 12,
    // @@protoc_insertion_point(enum_value:criu_req_type.SINGLE_PRE_DUMP)
    SINGLE_PRE_DUMP = 13,
}

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

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

    fn from_i32(value: i32) -> ::std::option::Option<Criu_req_type> {
        match value {
            0 => ::std::option::Option::Some(Criu_req_type::EMPTY),
            1 => ::std::option::Option::Some(Criu_req_type::DUMP),
            2 => ::std::option::Option::Some(Criu_req_type::RESTORE),
            3 => ::std::option::Option::Some(Criu_req_type::CHECK),
            4 => ::std::option::Option::Some(Criu_req_type::PRE_DUMP),
            5 => ::std::option::Option::Some(Criu_req_type::PAGE_SERVER),
            6 => ::std::option::Option::Some(Criu_req_type::NOTIFY),
            7 => ::std::option::Option::Some(Criu_req_type::CPUINFO_DUMP),
            8 => ::std::option::Option::Some(Criu_req_type::CPUINFO_CHECK),
            9 => ::std::option::Option::Some(Criu_req_type::FEATURE_CHECK),
            10 => ::std::option::Option::Some(Criu_req_type::VERSION),
            11 => ::std::option::Option::Some(Criu_req_type::WAIT_PID),
            12 => ::std::option::Option::Some(Criu_req_type::PAGE_SERVER_CHLD),
            13 => ::std::option::Option::Some(Criu_req_type::SINGLE_PRE_DUMP),
            _ => ::std::option::Option::None
        }
    }

    fn from_str(str: &str) -> ::std::option::Option<Criu_req_type> {
        match str {
            "EMPTY" => ::std::option::Option::Some(Criu_req_type::EMPTY),
            "DUMP" => ::std::option::Option::Some(Criu_req_type::DUMP),
            "RESTORE" => ::std::option::Option::Some(Criu_req_type::RESTORE),
            "CHECK" => ::std::option::Option::Some(Criu_req_type::CHECK),
            "PRE_DUMP" => ::std::option::Option::Some(Criu_req_type::PRE_DUMP),
            "PAGE_SERVER" => ::std::option::Option::Some(Criu_req_type::PAGE_SERVER),
            "NOTIFY" => ::std::option::Option::Some(Criu_req_type::NOTIFY),
            "CPUINFO_DUMP" => ::std::option::Option::Some(Criu_req_type::CPUINFO_DUMP),
            "CPUINFO_CHECK" => ::std::option::Option::Some(Criu_req_type::CPUINFO_CHECK),
            "FEATURE_CHECK" => ::std::option::Option::Some(Criu_req_type::FEATURE_CHECK),
            "VERSION" => ::std::option::Option::Some(Criu_req_type::VERSION),
            "WAIT_PID" => ::std::option::Option::Some(Criu_req_type::WAIT_PID),
            "PAGE_SERVER_CHLD" => ::std::option::Option::Some(Criu_req_type::PAGE_SERVER_CHLD),
            "SINGLE_PRE_DUMP" => ::std::option::Option::Some(Criu_req_type::SINGLE_PRE_DUMP),
            _ => ::std::option::Option::None
        }
    }

    const VALUES: &'static [Criu_req_type] = &[
        Criu_req_type::EMPTY,
        Criu_req_type::DUMP,
        Criu_req_type::RESTORE,
        Criu_req_type::CHECK,
        Criu_req_type::PRE_DUMP,
        Criu_req_type::PAGE_SERVER,
        Criu_req_type::NOTIFY,
        Criu_req_type::CPUINFO_DUMP,
        Criu_req_type::CPUINFO_CHECK,
        Criu_req_type::FEATURE_CHECK,
        Criu_req_type::VERSION,
        Criu_req_type::WAIT_PID,
        Criu_req_type::PAGE_SERVER_CHLD,
        Criu_req_type::SINGLE_PRE_DUMP,
    ];
}

impl ::protobuf::EnumFull for Criu_req_type {
    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("criu_req_type").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 Criu_req_type {
    fn default() -> Self {
        Criu_req_type::EMPTY
    }
}

impl Criu_req_type {
    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Criu_req_type>("criu_req_type")
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\trpc.proto\"g\n\x15criu_page_server_info\x12\x18\n\x07address\x18\x01\
    \x20\x01(\tR\x07address\x12\x12\n\x04port\x18\x02\x20\x01(\x05R\x04port\
    \x12\x10\n\x03pid\x18\x03\x20\x01(\x05R\x03pid\x12\x0e\n\x02fd\x18\x04\
    \x20\x01(\x05R\x02fd\"<\n\x0ecriu_veth_pair\x12\x13\n\x05if_in\x18\x01\
    \x20\x02(\tR\x04ifIn\x12\x15\n\x06if_out\x18\x02\x20\x02(\tR\x05ifOut\"3\
    \n\rext_mount_map\x12\x10\n\x03key\x18\x01\x20\x02(\tR\x03key\x12\x10\n\
    \x03val\x18\x02\x20\x02(\tR\x03val\"V\n\x0ejoin_namespace\x12\x0e\n\x02n\
    s\x18\x01\x20\x02(\tR\x02ns\x12\x17\n\x07ns_file\x18\x02\x20\x02(\tR\x06\
    nsFile\x12\x1b\n\textra_opt\x18\x03\x20\x01(\tR\x08extraOpt\".\n\ninheri\
    t_fd\x12\x10\n\x03key\x18\x01\x20\x02(\tR\x03key\x12\x0e\n\x02fd\x18\x02\
    \x20\x02(\x05R\x02fd\"5\n\x0bcgroup_root\x12\x12\n\x04ctrl\x18\x01\x20\
    \x01(\tR\x04ctrl\x12\x12\n\x04path\x18\x02\x20\x02(\tR\x04path\"\x1f\n\
    \x07unix_sk\x12\x14\n\x05inode\x18\x01\x20\x02(\rR\x05inode\"\xe4\x13\n\
    \tcriu_opts\x12&\n\rimages_dir_fd\x18\x01\x20\x02(\x05:\x02-1R\x0bimages\
    DirFd\x12\x1d\n\nimages_dir\x18D\x20\x01(\tR\timagesDir\x12\x10\n\x03pid\
    \x18\x02\x20\x01(\x05R\x03pid\x12#\n\rleave_running\x18\x03\x20\x01(\x08\
    R\x0cleaveRunning\x12\x1e\n\x0bext_unix_sk\x18\x04\x20\x01(\x08R\textUni\
    xSk\x12'\n\x0ftcp_established\x18\x05\x20\x01(\x08R\x0etcpEstablished\
    \x12'\n\x0fevasive_devices\x18\x06\x20\x01(\x08R\x0eevasiveDevices\x12\
    \x1b\n\tshell_job\x18\x07\x20\x01(\x08R\x08shellJob\x12\x1d\n\nfile_lock\
    s\x18\x08\x20\x01(\x08R\tfileLocks\x12\x1e\n\tlog_level\x18\t\x20\x01(\
    \x05:\x012R\x08logLevel\x12\x19\n\x08log_file\x18\n\x20\x01(\tR\x07logFi\
    le\x12&\n\x02ps\x18\x0b\x20\x01(\x0b2\x16.criu_page_server_infoR\x02ps\
    \x12%\n\x0enotify_scripts\x18\x0c\x20\x01(\x08R\rnotifyScripts\x12\x12\n\
    \x04root\x18\r\x20\x01(\tR\x04root\x12\x1d\n\nparent_img\x18\x0e\x20\x01\
    (\tR\tparentImg\x12\x1b\n\ttrack_mem\x18\x0f\x20\x01(\x08R\x08trackMem\
    \x12\x1d\n\nauto_dedup\x18\x10\x20\x01(\x08R\tautoDedup\x12\x1e\n\x0bwor\
    k_dir_fd\x18\x11\x20\x01(\x05R\tworkDirFd\x12\x1d\n\nlink_remap\x18\x12\
    \x20\x01(\x08R\tlinkRemap\x12%\n\x05veths\x18\x13\x20\x03(\x0b2\x0f.criu\
    _veth_pairR\x05veths\x12#\n\x07cpu_cap\x18\x14\x20\x01(\r:\n4294967295R\
    \x06cpuCap\x12\x1f\n\x0bforce_irmap\x18\x15\x20\x01(\x08R\nforceIrmap\
    \x12\x19\n\x08exec_cmd\x18\x16\x20\x03(\tR\x07execCmd\x12'\n\x07ext_mnt\
    \x18\x17\x20\x03(\x0b2\x0e.ext_mount_mapR\x06extMnt\x12%\n\x0emanage_cgr\
    oups\x18\x18\x20\x01(\x08R\rmanageCgroups\x12%\n\x07cg_root\x18\x19\x20\
    \x03(\x0b2\x0c.cgroup_rootR\x06cgRoot\x12\x1f\n\x0brst_sibling\x18\x1a\
    \x20\x01(\x08R\nrstSibling\x12*\n\ninherit_fd\x18\x1b\x20\x03(\x0b2\x0b.\
    inherit_fdR\tinheritFd\x12\x20\n\x0cauto_ext_mnt\x18\x1c\x20\x01(\x08R\n\
    autoExtMnt\x12\x1f\n\x0bext_sharing\x18\x1d\x20\x01(\x08R\nextSharing\
    \x12\x1f\n\x0bext_masters\x18\x1e\x20\x01(\x08R\nextMasters\x12\x19\n\
    \x08skip_mnt\x18\x1f\x20\x03(\tR\x07skipMnt\x12\x1b\n\tenable_fs\x18\x20\
    \x20\x03(\tR\x08enableFs\x12(\n\x0bunix_sk_ino\x18!\x20\x03(\x0b2\x08.un\
    ix_skR\tunixSkIno\x12=\n\x13manage_cgroups_mode\x18\"\x20\x01(\x0e2\r.cr\
    iu_cg_modeR\x11manageCgroupsMode\x12(\n\x0bghost_limit\x18#\x20\x01(\r:\
    \x071048576R\nghostLimit\x12(\n\x10irmap_scan_paths\x18$\x20\x03(\tR\x0e\
    irmapScanPaths\x12\x1a\n\x08external\x18%\x20\x03(\tR\x08external\x12\
    \x19\n\x08empty_ns\x18&\x20\x01(\rR\x07emptyNs\x12(\n\x07join_ns\x18'\
    \x20\x03(\x0b2\x0f.join_namespaceR\x06joinNs\x12!\n\x0ccgroup_props\x18)\
    \x20\x01(\tR\x0bcgroupProps\x12*\n\x11cgroup_props_file\x18*\x20\x01(\tR\
    \x0fcgroupPropsFile\x124\n\x16cgroup_dump_controller\x18+\x20\x03(\tR\
    \x14cgroupDumpController\x12#\n\rfreeze_cgroup\x18,\x20\x01(\tR\x0cfreez\
    eCgroup\x12\x18\n\x07timeout\x18-\x20\x01(\rR\x07timeout\x12+\n\x12tcp_s\
    kip_in_flight\x18.\x20\x01(\x08R\x0ftcpSkipInFlight\x12!\n\x0cweak_sysct\
    ls\x18/\x20\x01(\x08R\x0bweakSysctls\x12\x1d\n\nlazy_pages\x180\x20\x01(\
    \x08R\tlazyPages\x12\x1b\n\tstatus_fd\x181\x20\x01(\x05R\x08statusFd\x12\
    *\n\x11orphan_pts_master\x182\x20\x01(\x08R\x0forphanPtsMaster\x12\x1f\n\
    \x0bconfig_file\x183\x20\x01(\tR\nconfigFile\x12\x1b\n\ttcp_close\x184\
    \x20\x01(\x08R\x08tcpClose\x12\x1f\n\x0blsm_profile\x185\x20\x01(\tR\nls\
    mProfile\x12\x1d\n\ntls_cacert\x186\x20\x01(\tR\ttlsCacert\x12\x1b\n\ttl\
    s_cacrl\x187\x20\x01(\tR\x08tlsCacrl\x12\x19\n\x08tls_cert\x188\x20\x01(\
    \tR\x07tlsCert\x12\x17\n\x07tls_key\x189\x20\x01(\tR\x06tlsKey\x12\x10\n\
    \x03tls\x18:\x20\x01(\x08R\x03tls\x12'\n\x10tls_no_cn_verify\x18;\x20\
    \x01(\x08R\rtlsNoCnVerify\x12\x1f\n\x0bcgroup_yard\x18<\x20\x01(\tR\ncgr\
    oupYard\x12?\n\rpre_dump_mode\x18=\x20\x01(\x0e2\x13.criu_pre_dump_mode:\
    \x06SPLICER\x0bpreDumpMode\x12$\n\x0epidfd_store_sk\x18>\x20\x01(\x05R\
    \x0cpidfdStoreSk\x12*\n\x11lsm_mount_context\x18?\x20\x01(\tR\x0flsmMoun\
    tContext\x12F\n\x0cnetwork_lock\x18@\x20\x01(\x0e2\x19.criu_network_lock\
    _method:\x08IPTABLESR\x0bnetworkLock\x12*\n\x11mntns_compat_mode\x18A\
    \x20\x01(\x08R\x0fmntnsCompatMode\x12-\n\x13skip_file_rwx_check\x18B\x20\
    \x01(\x08R\x10skipFileRwxCheck\x12\"\n\x0cunprivileged\x18C\x20\x01(\x08\
    R\x0cunprivileged\x12#\n\rleave_stopped\x18E\x20\x01(\x08R\x0cleaveStopp\
    ed\x12#\n\rdisplay_stats\x18F\x20\x01(\x08R\x0cdisplayStats\x12\"\n\rlog\
    _to_stderr\x18G\x20\x01(\x08R\x0blogToStderr\",\n\x0ecriu_dump_resp\x12\
    \x1a\n\x08restored\x18\x01\x20\x01(\x08R\x08restored\"%\n\x11criu_restor\
    e_resp\x12\x10\n\x03pid\x18\x01\x20\x02(\x05R\x03pid\"7\n\x0bcriu_notify\
    \x12\x16\n\x06script\x18\x01\x20\x01(\tR\x06script\x12\x10\n\x03pid\x18\
    \x02\x20\x01(\x05R\x03pid\"l\n\rcriu_features\x12\x1b\n\tmem_track\x18\
    \x01\x20\x01(\x08R\x08memTrack\x12\x1d\n\nlazy_pages\x18\x02\x20\x01(\
    \x08R\tlazyPages\x12\x1f\n\x0bpidfd_store\x18\x03\x20\x01(\x08R\npidfdSt\
    ore\"\xd0\x01\n\x08criu_req\x12\"\n\x04type\x18\x01\x20\x02(\x0e2\x0e.cr\
    iu_req_typeR\x04type\x12\x1e\n\x04opts\x18\x02\x20\x01(\x0b2\n.criu_opts\
    R\x04opts\x12%\n\x0enotify_success\x18\x03\x20\x01(\x08R\rnotifySuccess\
    \x12\x1b\n\tkeep_open\x18\x04\x20\x01(\x08R\x08keepOpen\x12*\n\x08featur\
    es\x18\x05\x20\x01(\x0b2\x0e.criu_featuresR\x08features\x12\x10\n\x03pid\
    \x18\x06\x20\x01(\rR\x03pid\"\x8f\x03\n\tcriu_resp\x12\"\n\x04type\x18\
    \x01\x20\x02(\x0e2\x0e.criu_req_typeR\x04type\x12\x18\n\x07success\x18\
    \x02\x20\x02(\x08R\x07success\x12#\n\x04dump\x18\x03\x20\x01(\x0b2\x0f.c\
    riu_dump_respR\x04dump\x12,\n\x07restore\x18\x04\x20\x01(\x0b2\x12.criu_\
    restore_respR\x07restore\x12$\n\x06notify\x18\x05\x20\x01(\x0b2\x0c.criu\
    _notifyR\x06notify\x12&\n\x02ps\x18\x06\x20\x01(\x0b2\x16.criu_page_serv\
    er_infoR\x02ps\x12\x19\n\x08cr_errno\x18\x07\x20\x01(\x05R\x07crErrno\
    \x12*\n\x08features\x18\x08\x20\x01(\x0b2\x0e.criu_featuresR\x08features\
    \x12\x1b\n\tcr_errmsg\x18\t\x20\x01(\tR\x08crErrmsg\x12'\n\x07version\
    \x18\n\x20\x01(\x0b2\r.criu_versionR\x07version\x12\x16\n\x06status\x18\
    \x0b\x20\x01(\x05R\x06status\"\xb0\x01\n\x0ccriu_version\x12!\n\x0cmajor\
    _number\x18\x01\x20\x02(\x05R\x0bmajorNumber\x12!\n\x0cminor_number\x18\
    \x02\x20\x02(\x05R\x0bminorNumber\x12\x14\n\x05gitid\x18\x03\x20\x01(\tR\
    \x05gitid\x12\x1a\n\x08sublevel\x18\x04\x20\x01(\x05R\x08sublevel\x12\
    \x14\n\x05extra\x18\x05\x20\x01(\x05R\x05extra\x12\x12\n\x04name\x18\x06\
    \x20\x01(\tR\x04name*_\n\x0ccriu_cg_mode\x12\n\n\x06IGNORE\x10\0\x12\x0b\
    \n\x07CG_NONE\x10\x01\x12\t\n\x05PROPS\x10\x02\x12\x08\n\x04SOFT\x10\x03\
    \x12\x08\n\x04FULL\x10\x04\x12\n\n\x06STRICT\x10\x05\x12\x0b\n\x07DEFAUL\
    T\x10\x06*@\n\x18criu_network_lock_method\x12\x0c\n\x08IPTABLES\x10\x01\
    \x12\x0c\n\x08NFTABLES\x10\x02\x12\x08\n\x04SKIP\x10\x03*-\n\x12criu_pre\
    _dump_mode\x12\n\n\x06SPLICE\x10\x01\x12\x0b\n\x07VM_READ\x10\x02*\xe5\
    \x01\n\rcriu_req_type\x12\t\n\x05EMPTY\x10\0\x12\x08\n\x04DUMP\x10\x01\
    \x12\x0b\n\x07RESTORE\x10\x02\x12\t\n\x05CHECK\x10\x03\x12\x0c\n\x08PRE_\
    DUMP\x10\x04\x12\x0f\n\x0bPAGE_SERVER\x10\x05\x12\n\n\x06NOTIFY\x10\x06\
    \x12\x10\n\x0cCPUINFO_DUMP\x10\x07\x12\x11\n\rCPUINFO_CHECK\x10\x08\x12\
    \x11\n\rFEATURE_CHECK\x10\t\x12\x0b\n\x07VERSION\x10\n\x12\x0c\n\x08WAIT\
    _PID\x10\x0b\x12\x14\n\x10PAGE_SERVER_CHLD\x10\x0c\x12\x13\n\x0fSINGLE_P\
    RE_DUMP\x10\r\
";

/// `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(15);
            messages.push(Criu_page_server_info::generated_message_descriptor_data());
            messages.push(Criu_veth_pair::generated_message_descriptor_data());
            messages.push(Ext_mount_map::generated_message_descriptor_data());
            messages.push(Join_namespace::generated_message_descriptor_data());
            messages.push(Inherit_fd::generated_message_descriptor_data());
            messages.push(Cgroup_root::generated_message_descriptor_data());
            messages.push(Unix_sk::generated_message_descriptor_data());
            messages.push(Criu_opts::generated_message_descriptor_data());
            messages.push(Criu_dump_resp::generated_message_descriptor_data());
            messages.push(Criu_restore_resp::generated_message_descriptor_data());
            messages.push(Criu_notify::generated_message_descriptor_data());
            messages.push(Criu_features::generated_message_descriptor_data());
            messages.push(Criu_req::generated_message_descriptor_data());
            messages.push(Criu_resp::generated_message_descriptor_data());
            messages.push(Criu_version::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(4);
            enums.push(Criu_cg_mode::generated_enum_descriptor_data());
            enums.push(Criu_network_lock_method::generated_enum_descriptor_data());
            enums.push(Criu_pre_dump_mode::generated_enum_descriptor_data());
            enums.push(Criu_req_type::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}
