// This file is generated by rust-protobuf 3.2.0. Do not edit
// .proto file is parsed by pure
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `BasicApi.proto`

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.GetWorldInfoOut)
pub struct GetWorldInfoOut {
    // message fields
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.mode)
    pub mode: ::std::option::Option<::protobuf::EnumOrUnknown<get_world_info_out::Mode>>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.save_dir)
    pub save_dir: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.world_name)
    pub world_name: ::protobuf::MessageField<super::Basic::NameInfo>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.civ_id)
    pub civ_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.site_id)
    pub site_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.group_id)
    pub group_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.race_id)
    pub race_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.player_unit_id)
    pub player_unit_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.player_histfig_id)
    pub player_histfig_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.GetWorldInfoOut.companion_histfig_ids)
    pub companion_histfig_ids: ::std::vec::Vec<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.GetWorldInfoOut.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // required .dfproto.GetWorldInfoOut.Mode mode = 1;

    pub fn mode(&self) -> get_world_info_out::Mode {
        match self.mode {
            Some(e) => e.enum_value_or(get_world_info_out::Mode::MODE_DWARF),
            None => get_world_info_out::Mode::MODE_DWARF,
        }
    }

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

    pub fn has_mode(&self) -> bool {
        self.mode.is_some()
    }

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

    // required string save_dir = 2;

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

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

    pub fn has_save_dir(&self) -> bool {
        self.save_dir.is_some()
    }

    // Param is passed by value, moved
    pub fn set_save_dir(&mut self, v: ::std::string::String) {
        self.save_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_save_dir(&mut self) -> &mut ::std::string::String {
        if self.save_dir.is_none() {
            self.save_dir = ::std::option::Option::Some(::std::string::String::new());
        }
        self.save_dir.as_mut().unwrap()
    }

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

    // optional int32 civ_id = 4;

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

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

    pub fn has_civ_id(&self) -> bool {
        self.civ_id.is_some()
    }

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

    // optional int32 site_id = 5;

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

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

    pub fn has_site_id(&self) -> bool {
        self.site_id.is_some()
    }

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

    // optional int32 group_id = 6;

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

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

    pub fn has_group_id(&self) -> bool {
        self.group_id.is_some()
    }

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

    // optional int32 race_id = 7;

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

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

    pub fn has_race_id(&self) -> bool {
        self.race_id.is_some()
    }

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

    // optional int32 player_unit_id = 8;

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

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

    pub fn has_player_unit_id(&self) -> bool {
        self.player_unit_id.is_some()
    }

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

    // optional int32 player_histfig_id = 9;

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

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

    pub fn has_player_histfig_id(&self) -> bool {
        self.player_histfig_id.is_some()
    }

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(10);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "mode",
            |m: &GetWorldInfoOut| { &m.mode },
            |m: &mut GetWorldInfoOut| { &mut m.mode },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "save_dir",
            |m: &GetWorldInfoOut| { &m.save_dir },
            |m: &mut GetWorldInfoOut| { &mut m.save_dir },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::Basic::NameInfo>(
            "world_name",
            |m: &GetWorldInfoOut| { &m.world_name },
            |m: &mut GetWorldInfoOut| { &mut m.world_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "civ_id",
            |m: &GetWorldInfoOut| { &m.civ_id },
            |m: &mut GetWorldInfoOut| { &mut m.civ_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "site_id",
            |m: &GetWorldInfoOut| { &m.site_id },
            |m: &mut GetWorldInfoOut| { &mut m.site_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "group_id",
            |m: &GetWorldInfoOut| { &m.group_id },
            |m: &mut GetWorldInfoOut| { &mut m.group_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "race_id",
            |m: &GetWorldInfoOut| { &m.race_id },
            |m: &mut GetWorldInfoOut| { &mut m.race_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "player_unit_id",
            |m: &GetWorldInfoOut| { &m.player_unit_id },
            |m: &mut GetWorldInfoOut| { &mut m.player_unit_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "player_histfig_id",
            |m: &GetWorldInfoOut| { &m.player_histfig_id },
            |m: &mut GetWorldInfoOut| { &mut m.player_histfig_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "companion_histfig_ids",
            |m: &GetWorldInfoOut| { &m.companion_histfig_ids },
            |m: &mut GetWorldInfoOut| { &mut m.companion_histfig_ids },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetWorldInfoOut>(
            "GetWorldInfoOut",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        if self.mode.is_none() {
            return false;
        }
        if self.save_dir.is_none() {
            return false;
        }
        for v in &self.world_name {
            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.mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
                },
                18 => {
                    self.save_dir = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.world_name)?;
                },
                32 => {
                    self.civ_id = ::std::option::Option::Some(is.read_int32()?);
                },
                40 => {
                    self.site_id = ::std::option::Option::Some(is.read_int32()?);
                },
                48 => {
                    self.group_id = ::std::option::Option::Some(is.read_int32()?);
                },
                56 => {
                    self.race_id = ::std::option::Option::Some(is.read_int32()?);
                },
                64 => {
                    self.player_unit_id = ::std::option::Option::Some(is.read_int32()?);
                },
                72 => {
                    self.player_histfig_id = ::std::option::Option::Some(is.read_int32()?);
                },
                82 => {
                    is.read_repeated_packed_int32_into(&mut self.companion_histfig_ids)?;
                },
                80 => {
                    self.companion_histfig_ids.push(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.mode {
            my_size += ::protobuf::rt::int32_size(1, v.value());
        }
        if let Some(v) = self.save_dir.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.world_name.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.civ_id {
            my_size += ::protobuf::rt::int32_size(4, v);
        }
        if let Some(v) = self.site_id {
            my_size += ::protobuf::rt::int32_size(5, v);
        }
        if let Some(v) = self.group_id {
            my_size += ::protobuf::rt::int32_size(6, v);
        }
        if let Some(v) = self.race_id {
            my_size += ::protobuf::rt::int32_size(7, v);
        }
        if let Some(v) = self.player_unit_id {
            my_size += ::protobuf::rt::int32_size(8, v);
        }
        if let Some(v) = self.player_histfig_id {
            my_size += ::protobuf::rt::int32_size(9, v);
        }
        for value in &self.companion_histfig_ids {
            my_size += ::protobuf::rt::int32_size(10, *value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.mode {
            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
        }
        if let Some(v) = self.save_dir.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.world_name.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if let Some(v) = self.civ_id {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.site_id {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.group_id {
            os.write_int32(6, v)?;
        }
        if let Some(v) = self.race_id {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.player_unit_id {
            os.write_int32(8, v)?;
        }
        if let Some(v) = self.player_histfig_id {
            os.write_int32(9, v)?;
        }
        for v in &self.companion_histfig_ids {
            os.write_int32(10, *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() -> GetWorldInfoOut {
        GetWorldInfoOut::new()
    }

    fn clear(&mut self) {
        self.mode = ::std::option::Option::None;
        self.save_dir = ::std::option::Option::None;
        self.world_name.clear();
        self.civ_id = ::std::option::Option::None;
        self.site_id = ::std::option::Option::None;
        self.group_id = ::std::option::Option::None;
        self.race_id = ::std::option::Option::None;
        self.player_unit_id = ::std::option::Option::None;
        self.player_histfig_id = ::std::option::Option::None;
        self.companion_histfig_ids.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static GetWorldInfoOut {
        static instance: GetWorldInfoOut = GetWorldInfoOut {
            mode: ::std::option::Option::None,
            save_dir: ::std::option::Option::None,
            world_name: ::protobuf::MessageField::none(),
            civ_id: ::std::option::Option::None,
            site_id: ::std::option::Option::None,
            group_id: ::std::option::Option::None,
            race_id: ::std::option::Option::None,
            player_unit_id: ::std::option::Option::None,
            player_histfig_id: ::std::option::Option::None,
            companion_histfig_ids: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

/// Nested message and enums of message `GetWorldInfoOut`
pub mod get_world_info_out {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:dfproto.GetWorldInfoOut.Mode)
    pub enum Mode {
        // @@protoc_insertion_point(enum_value:dfproto.GetWorldInfoOut.Mode.MODE_DWARF)
        MODE_DWARF = 1,
        // @@protoc_insertion_point(enum_value:dfproto.GetWorldInfoOut.Mode.MODE_ADVENTURE)
        MODE_ADVENTURE = 2,
        // @@protoc_insertion_point(enum_value:dfproto.GetWorldInfoOut.Mode.MODE_LEGENDS)
        MODE_LEGENDS = 3,
    }

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

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

        fn from_i32(value: i32) -> ::std::option::Option<Mode> {
            match value {
                1 => ::std::option::Option::Some(Mode::MODE_DWARF),
                2 => ::std::option::Option::Some(Mode::MODE_ADVENTURE),
                3 => ::std::option::Option::Some(Mode::MODE_LEGENDS),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Mode] = &[
            Mode::MODE_DWARF,
            Mode::MODE_ADVENTURE,
            Mode::MODE_LEGENDS,
        ];
    }

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

        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
            let index = match self {
                Mode::MODE_DWARF => 0,
                Mode::MODE_ADVENTURE => 1,
                Mode::MODE_LEGENDS => 2,
            };
            Self::enum_descriptor().value_by_index(index)
        }
    }

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListEnumsOut)
pub struct ListEnumsOut {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.material_flags)
    pub material_flags: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.inorganic_flags)
    pub inorganic_flags: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.unit_flags1)
    pub unit_flags1: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.unit_flags2)
    pub unit_flags2: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.unit_flags3)
    pub unit_flags3: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.unit_labor)
    pub unit_labor: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.job_skill)
    pub job_skill: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.cie_add_tag_mask1)
    pub cie_add_tag_mask1: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.cie_add_tag_mask2)
    pub cie_add_tag_mask2: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.death_info_flags)
    pub death_info_flags: ::std::vec::Vec<super::Basic::EnumItemName>,
    // @@protoc_insertion_point(field:dfproto.ListEnumsOut.profession)
    pub profession: ::std::vec::Vec<super::Basic::EnumItemName>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListEnumsOut.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_vec_simpler_accessor::<_, _>(
            "material_flags",
            |m: &ListEnumsOut| { &m.material_flags },
            |m: &mut ListEnumsOut| { &mut m.material_flags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "inorganic_flags",
            |m: &ListEnumsOut| { &m.inorganic_flags },
            |m: &mut ListEnumsOut| { &mut m.inorganic_flags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "unit_flags1",
            |m: &ListEnumsOut| { &m.unit_flags1 },
            |m: &mut ListEnumsOut| { &mut m.unit_flags1 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "unit_flags2",
            |m: &ListEnumsOut| { &m.unit_flags2 },
            |m: &mut ListEnumsOut| { &mut m.unit_flags2 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "unit_flags3",
            |m: &ListEnumsOut| { &m.unit_flags3 },
            |m: &mut ListEnumsOut| { &mut m.unit_flags3 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "unit_labor",
            |m: &ListEnumsOut| { &m.unit_labor },
            |m: &mut ListEnumsOut| { &mut m.unit_labor },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "job_skill",
            |m: &ListEnumsOut| { &m.job_skill },
            |m: &mut ListEnumsOut| { &mut m.job_skill },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "cie_add_tag_mask1",
            |m: &ListEnumsOut| { &m.cie_add_tag_mask1 },
            |m: &mut ListEnumsOut| { &mut m.cie_add_tag_mask1 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "cie_add_tag_mask2",
            |m: &ListEnumsOut| { &m.cie_add_tag_mask2 },
            |m: &mut ListEnumsOut| { &mut m.cie_add_tag_mask2 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "death_info_flags",
            |m: &ListEnumsOut| { &m.death_info_flags },
            |m: &mut ListEnumsOut| { &mut m.death_info_flags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "profession",
            |m: &ListEnumsOut| { &m.profession },
            |m: &mut ListEnumsOut| { &mut m.profession },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListEnumsOut>(
            "ListEnumsOut",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        for v in &self.material_flags {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.inorganic_flags {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.unit_flags1 {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.unit_flags2 {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.unit_flags3 {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.unit_labor {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.job_skill {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.cie_add_tag_mask1 {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.cie_add_tag_mask2 {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.death_info_flags {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.profession {
            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 {
                10 => {
                    self.material_flags.push(is.read_message()?);
                },
                18 => {
                    self.inorganic_flags.push(is.read_message()?);
                },
                26 => {
                    self.unit_flags1.push(is.read_message()?);
                },
                34 => {
                    self.unit_flags2.push(is.read_message()?);
                },
                42 => {
                    self.unit_flags3.push(is.read_message()?);
                },
                50 => {
                    self.unit_labor.push(is.read_message()?);
                },
                58 => {
                    self.job_skill.push(is.read_message()?);
                },
                66 => {
                    self.cie_add_tag_mask1.push(is.read_message()?);
                },
                74 => {
                    self.cie_add_tag_mask2.push(is.read_message()?);
                },
                82 => {
                    self.death_info_flags.push(is.read_message()?);
                },
                90 => {
                    self.profession.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.material_flags {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.inorganic_flags {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.unit_flags1 {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.unit_flags2 {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.unit_flags3 {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.unit_labor {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.job_skill {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.cie_add_tag_mask1 {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.cie_add_tag_mask2 {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.death_info_flags {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.profession {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.material_flags {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        for v in &self.inorganic_flags {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        for v in &self.unit_flags1 {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.unit_flags2 {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for v in &self.unit_flags3 {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        for v in &self.unit_labor {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        for v in &self.job_skill {
            ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        };
        for v in &self.cie_add_tag_mask1 {
            ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
        };
        for v in &self.cie_add_tag_mask2 {
            ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
        };
        for v in &self.death_info_flags {
            ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
        };
        for v in &self.profession {
            ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

    fn clear(&mut self) {
        self.material_flags.clear();
        self.inorganic_flags.clear();
        self.unit_flags1.clear();
        self.unit_flags2.clear();
        self.unit_flags3.clear();
        self.unit_labor.clear();
        self.job_skill.clear();
        self.cie_add_tag_mask1.clear();
        self.cie_add_tag_mask2.clear();
        self.death_info_flags.clear();
        self.profession.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ListEnumsOut {
        static instance: ListEnumsOut = ListEnumsOut {
            material_flags: ::std::vec::Vec::new(),
            inorganic_flags: ::std::vec::Vec::new(),
            unit_flags1: ::std::vec::Vec::new(),
            unit_flags2: ::std::vec::Vec::new(),
            unit_flags3: ::std::vec::Vec::new(),
            unit_labor: ::std::vec::Vec::new(),
            job_skill: ::std::vec::Vec::new(),
            cie_add_tag_mask1: ::std::vec::Vec::new(),
            cie_add_tag_mask2: ::std::vec::Vec::new(),
            death_info_flags: ::std::vec::Vec::new(),
            profession: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListJobSkillsOut)
pub struct ListJobSkillsOut {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListJobSkillsOut.skill)
    pub skill: ::std::vec::Vec<super::Basic::JobSkillAttr>,
    // @@protoc_insertion_point(field:dfproto.ListJobSkillsOut.profession)
    pub profession: ::std::vec::Vec<super::Basic::ProfessionAttr>,
    // @@protoc_insertion_point(field:dfproto.ListJobSkillsOut.labor)
    pub labor: ::std::vec::Vec<super::Basic::UnitLaborAttr>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListJobSkillsOut.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_vec_simpler_accessor::<_, _>(
            "skill",
            |m: &ListJobSkillsOut| { &m.skill },
            |m: &mut ListJobSkillsOut| { &mut m.skill },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "profession",
            |m: &ListJobSkillsOut| { &m.profession },
            |m: &mut ListJobSkillsOut| { &mut m.profession },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "labor",
            |m: &ListJobSkillsOut| { &m.labor },
            |m: &mut ListJobSkillsOut| { &mut m.labor },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListJobSkillsOut>(
            "ListJobSkillsOut",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        for v in &self.skill {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.profession {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.labor {
            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 {
                10 => {
                    self.skill.push(is.read_message()?);
                },
                18 => {
                    self.profession.push(is.read_message()?);
                },
                26 => {
                    self.labor.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn default_instance() -> &'static ListJobSkillsOut {
        static instance: ListJobSkillsOut = ListJobSkillsOut {
            skill: ::std::vec::Vec::new(),
            profession: ::std::vec::Vec::new(),
            labor: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListMaterialsIn)
pub struct ListMaterialsIn {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListMaterialsIn.mask)
    pub mask: ::protobuf::MessageField<super::Basic::BasicMaterialInfoMask>,
    // @@protoc_insertion_point(field:dfproto.ListMaterialsIn.id_list)
    pub id_list: ::std::vec::Vec<super::Basic::BasicMaterialId>,
    // @@protoc_insertion_point(field:dfproto.ListMaterialsIn.builtin)
    pub builtin: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dfproto.ListMaterialsIn.inorganic)
    pub inorganic: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dfproto.ListMaterialsIn.creatures)
    pub creatures: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dfproto.ListMaterialsIn.plants)
    pub plants: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListMaterialsIn.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional bool builtin = 3;

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

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

    pub fn has_builtin(&self) -> bool {
        self.builtin.is_some()
    }

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

    // optional bool inorganic = 4;

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

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

    pub fn has_inorganic(&self) -> bool {
        self.inorganic.is_some()
    }

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

    // optional bool creatures = 5;

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

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

    pub fn has_creatures(&self) -> bool {
        self.creatures.is_some()
    }

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

    // optional bool plants = 6;

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

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

    pub fn has_plants(&self) -> bool {
        self.plants.is_some()
    }

    // Param is passed by value, moved
    pub fn set_plants(&mut self, v: bool) {
        self.plants = ::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_message_field_accessor::<_, super::Basic::BasicMaterialInfoMask>(
            "mask",
            |m: &ListMaterialsIn| { &m.mask },
            |m: &mut ListMaterialsIn| { &mut m.mask },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "id_list",
            |m: &ListMaterialsIn| { &m.id_list },
            |m: &mut ListMaterialsIn| { &mut m.id_list },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "builtin",
            |m: &ListMaterialsIn| { &m.builtin },
            |m: &mut ListMaterialsIn| { &mut m.builtin },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "inorganic",
            |m: &ListMaterialsIn| { &m.inorganic },
            |m: &mut ListMaterialsIn| { &mut m.inorganic },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "creatures",
            |m: &ListMaterialsIn| { &m.creatures },
            |m: &mut ListMaterialsIn| { &mut m.creatures },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "plants",
            |m: &ListMaterialsIn| { &m.plants },
            |m: &mut ListMaterialsIn| { &mut m.plants },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListMaterialsIn>(
            "ListMaterialsIn",
            fields,
            oneofs,
        )
    }
}

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

    fn is_initialized(&self) -> bool {
        for v in &self.mask {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.id_list {
            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 {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.mask)?;
                },
                18 => {
                    self.id_list.push(is.read_message()?);
                },
                24 => {
                    self.builtin = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.inorganic = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.creatures = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.plants = ::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.mask.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.id_list {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.builtin {
            my_size += 1 + 1;
        }
        if let Some(v) = self.inorganic {
            my_size += 1 + 1;
        }
        if let Some(v) = self.creatures {
            my_size += 1 + 1;
        }
        if let Some(v) = self.plants {
            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.mask.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.id_list {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if let Some(v) = self.builtin {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.inorganic {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.creatures {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.plants {
            os.write_bool(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() -> ListMaterialsIn {
        ListMaterialsIn::new()
    }

    fn clear(&mut self) {
        self.mask.clear();
        self.id_list.clear();
        self.builtin = ::std::option::Option::None;
        self.inorganic = ::std::option::Option::None;
        self.creatures = ::std::option::Option::None;
        self.plants = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ListMaterialsIn {
        static instance: ListMaterialsIn = ListMaterialsIn {
            mask: ::protobuf::MessageField::none(),
            id_list: ::std::vec::Vec::new(),
            builtin: ::std::option::Option::None,
            inorganic: ::std::option::Option::None,
            creatures: ::std::option::Option::None,
            plants: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListMaterialsOut)
pub struct ListMaterialsOut {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListMaterialsOut.value)
    pub value: ::std::vec::Vec<super::Basic::BasicMaterialInfo>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListMaterialsOut.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

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

    fn is_initialized(&self) -> bool {
        for v in &self.value {
            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 {
                10 => {
                    self.value.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListUnitsIn)
pub struct ListUnitsIn {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.mask)
    pub mask: ::protobuf::MessageField<super::Basic::BasicUnitInfoMask>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.id_list)
    pub id_list: ::std::vec::Vec<i32>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.scan_all)
    pub scan_all: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.race)
    pub race: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.civ_id)
    pub civ_id: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.dead)
    pub dead: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.alive)
    pub alive: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dfproto.ListUnitsIn.sane)
    pub sane: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListUnitsIn.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    // optional bool scan_all = 5;

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

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

    pub fn has_scan_all(&self) -> bool {
        self.scan_all.is_some()
    }

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

    // optional int32 race = 3;

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

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

    pub fn has_race(&self) -> bool {
        self.race.is_some()
    }

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

    // optional int32 civ_id = 4;

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

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

    pub fn has_civ_id(&self) -> bool {
        self.civ_id.is_some()
    }

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

    // optional bool dead = 6;

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

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

    pub fn has_dead(&self) -> bool {
        self.dead.is_some()
    }

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

    // optional bool alive = 7;

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

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

    pub fn has_alive(&self) -> bool {
        self.alive.is_some()
    }

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

    // optional bool sane = 8;

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

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

    pub fn has_sane(&self) -> bool {
        self.sane.is_some()
    }

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(8);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::Basic::BasicUnitInfoMask>(
            "mask",
            |m: &ListUnitsIn| { &m.mask },
            |m: &mut ListUnitsIn| { &mut m.mask },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "id_list",
            |m: &ListUnitsIn| { &m.id_list },
            |m: &mut ListUnitsIn| { &mut m.id_list },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "scan_all",
            |m: &ListUnitsIn| { &m.scan_all },
            |m: &mut ListUnitsIn| { &mut m.scan_all },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "race",
            |m: &ListUnitsIn| { &m.race },
            |m: &mut ListUnitsIn| { &mut m.race },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "civ_id",
            |m: &ListUnitsIn| { &m.civ_id },
            |m: &mut ListUnitsIn| { &mut m.civ_id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "dead",
            |m: &ListUnitsIn| { &m.dead },
            |m: &mut ListUnitsIn| { &mut m.dead },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "alive",
            |m: &ListUnitsIn| { &m.alive },
            |m: &mut ListUnitsIn| { &mut m.alive },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "sane",
            |m: &ListUnitsIn| { &m.sane },
            |m: &mut ListUnitsIn| { &mut m.sane },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListUnitsIn>(
            "ListUnitsIn",
            fields,
            oneofs,
        )
    }
}

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

    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 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.mask)?;
                },
                18 => {
                    is.read_repeated_packed_int32_into(&mut self.id_list)?;
                },
                16 => {
                    self.id_list.push(is.read_int32()?);
                },
                40 => {
                    self.scan_all = ::std::option::Option::Some(is.read_bool()?);
                },
                24 => {
                    self.race = ::std::option::Option::Some(is.read_int32()?);
                },
                32 => {
                    self.civ_id = ::std::option::Option::Some(is.read_int32()?);
                },
                48 => {
                    self.dead = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.alive = ::std::option::Option::Some(is.read_bool()?);
                },
                64 => {
                    self.sane = ::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.mask.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.id_list {
            my_size += ::protobuf::rt::int32_size(2, *value);
        };
        if let Some(v) = self.scan_all {
            my_size += 1 + 1;
        }
        if let Some(v) = self.race {
            my_size += ::protobuf::rt::int32_size(3, v);
        }
        if let Some(v) = self.civ_id {
            my_size += ::protobuf::rt::int32_size(4, v);
        }
        if let Some(v) = self.dead {
            my_size += 1 + 1;
        }
        if let Some(v) = self.alive {
            my_size += 1 + 1;
        }
        if let Some(v) = self.sane {
            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.mask.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.id_list {
            os.write_int32(2, *v)?;
        };
        if let Some(v) = self.scan_all {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.race {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.civ_id {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.dead {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.alive {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.sane {
            os.write_bool(8, 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() -> ListUnitsIn {
        ListUnitsIn::new()
    }

    fn clear(&mut self) {
        self.mask.clear();
        self.id_list.clear();
        self.scan_all = ::std::option::Option::None;
        self.race = ::std::option::Option::None;
        self.civ_id = ::std::option::Option::None;
        self.dead = ::std::option::Option::None;
        self.alive = ::std::option::Option::None;
        self.sane = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ListUnitsIn {
        static instance: ListUnitsIn = ListUnitsIn {
            mask: ::protobuf::MessageField::none(),
            id_list: ::std::vec::Vec::new(),
            scan_all: ::std::option::Option::None,
            race: ::std::option::Option::None,
            civ_id: ::std::option::Option::None,
            dead: ::std::option::Option::None,
            alive: ::std::option::Option::None,
            sane: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListUnitsOut)
pub struct ListUnitsOut {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListUnitsOut.value)
    pub value: ::std::vec::Vec<super::Basic::BasicUnitInfo>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListUnitsOut.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

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

    fn is_initialized(&self) -> bool {
        for v in &self.value {
            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 {
                10 => {
                    self.value.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListSquadsIn>(
            "ListSquadsIn",
            fields,
            oneofs,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.ListSquadsOut)
pub struct ListSquadsOut {
    // message fields
    // @@protoc_insertion_point(field:dfproto.ListSquadsOut.value)
    pub value: ::std::vec::Vec<super::Basic::BasicSquadInfo>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.ListSquadsOut.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

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

    fn is_initialized(&self) -> bool {
        for v in &self.value {
            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 {
                10 => {
                    self.value.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:dfproto.SetUnitLaborsIn)
pub struct SetUnitLaborsIn {
    // message fields
    // @@protoc_insertion_point(field:dfproto.SetUnitLaborsIn.change)
    pub change: ::std::vec::Vec<super::Basic::UnitLaborState>,
    // special fields
    // @@protoc_insertion_point(special_field:dfproto.SetUnitLaborsIn.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

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

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

    fn is_initialized(&self) -> bool {
        for v in &self.change {
            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 {
                10 => {
                    self.change.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x0eBasicApi.proto\x12\x07dfproto\x1a\x0bBasic.proto\"\xb9\x03\n\x0fGe\
    tWorldInfoOut\x121\n\x04mode\x18\x01\x20\x02(\x0e2\x1d.dfproto.GetWorldI\
    nfoOut.ModeR\x04mode\x12\x19\n\x08save_dir\x18\x02\x20\x02(\tR\x07saveDi\
    r\x120\n\nworld_name\x18\x03\x20\x01(\x0b2\x11.dfproto.NameInfoR\tworldN\
    ame\x12\x15\n\x06civ_id\x18\x04\x20\x01(\x05R\x05civId\x12\x17\n\x07site\
    _id\x18\x05\x20\x01(\x05R\x06siteId\x12\x19\n\x08group_id\x18\x06\x20\
    \x01(\x05R\x07groupId\x12\x17\n\x07race_id\x18\x07\x20\x01(\x05R\x06race\
    Id\x12$\n\x0eplayer_unit_id\x18\x08\x20\x01(\x05R\x0cplayerUnitId\x12*\n\
    \x11player_histfig_id\x18\t\x20\x01(\x05R\x0fplayerHistfigId\x122\n\x15c\
    ompanion_histfig_ids\x18\n\x20\x03(\x05R\x13companionHistfigIds\"<\n\x04\
    Mode\x12\x0e\n\nMODE_DWARF\x10\x01\x12\x12\n\x0eMODE_ADVENTURE\x10\x02\
    \x12\x10\n\x0cMODE_LEGENDS\x10\x03\"\x9a\x05\n\x0cListEnumsOut\x12<\n\
    \x0ematerial_flags\x18\x01\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\rmate\
    rialFlags\x12>\n\x0finorganic_flags\x18\x02\x20\x03(\x0b2\x15.dfproto.En\
    umItemNameR\x0einorganicFlags\x126\n\x0bunit_flags1\x18\x03\x20\x03(\x0b\
    2\x15.dfproto.EnumItemNameR\nunitFlags1\x126\n\x0bunit_flags2\x18\x04\
    \x20\x03(\x0b2\x15.dfproto.EnumItemNameR\nunitFlags2\x126\n\x0bunit_flag\
    s3\x18\x05\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\nunitFlags3\x124\n\nu\
    nit_labor\x18\x06\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\tunitLabor\x12\
    2\n\tjob_skill\x18\x07\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\x08jobSki\
    ll\x12@\n\x11cie_add_tag_mask1\x18\x08\x20\x03(\x0b2\x15.dfproto.EnumIte\
    mNameR\x0ecieAddTagMask1\x12@\n\x11cie_add_tag_mask2\x18\t\x20\x03(\x0b2\
    \x15.dfproto.EnumItemNameR\x0ecieAddTagMask2\x12?\n\x10death_info_flags\
    \x18\n\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\x0edeathInfoFlags\x125\n\
    \nprofession\x18\x0b\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\nprofession\
    \"\xa6\x01\n\x10ListJobSkillsOut\x12+\n\x05skill\x18\x01\x20\x03(\x0b2\
    \x15.dfproto.JobSkillAttrR\x05skill\x127\n\nprofession\x18\x02\x20\x03(\
    \x0b2\x17.dfproto.ProfessionAttrR\nprofession\x12,\n\x05labor\x18\x03\
    \x20\x03(\x0b2\x16.dfproto.UnitLaborAttrR\x05labor\"\xe6\x01\n\x0fListMa\
    terialsIn\x122\n\x04mask\x18\x01\x20\x01(\x0b2\x1e.dfproto.BasicMaterial\
    InfoMaskR\x04mask\x121\n\x07id_list\x18\x02\x20\x03(\x0b2\x18.dfproto.Ba\
    sicMaterialIdR\x06idList\x12\x18\n\x07builtin\x18\x03\x20\x01(\x08R\x07b\
    uiltin\x12\x1c\n\tinorganic\x18\x04\x20\x01(\x08R\tinorganic\x12\x1c\n\t\
    creatures\x18\x05\x20\x01(\x08R\tcreatures\x12\x16\n\x06plants\x18\x06\
    \x20\x01(\x08R\x06plants\"D\n\x10ListMaterialsOut\x120\n\x05value\x18\
    \x01\x20\x03(\x0b2\x1a.dfproto.BasicMaterialInfoR\x05value\"\xda\x01\n\
    \x0bListUnitsIn\x12.\n\x04mask\x18\x01\x20\x01(\x0b2\x1a.dfproto.BasicUn\
    itInfoMaskR\x04mask\x12\x17\n\x07id_list\x18\x02\x20\x03(\x05R\x06idList\
    \x12\x19\n\x08scan_all\x18\x05\x20\x01(\x08R\x07scanAll\x12\x12\n\x04rac\
    e\x18\x03\x20\x01(\x05R\x04race\x12\x15\n\x06civ_id\x18\x04\x20\x01(\x05\
    R\x05civId\x12\x12\n\x04dead\x18\x06\x20\x01(\x08R\x04dead\x12\x14\n\x05\
    alive\x18\x07\x20\x01(\x08R\x05alive\x12\x12\n\x04sane\x18\x08\x20\x01(\
    \x08R\x04sane\"<\n\x0cListUnitsOut\x12,\n\x05value\x18\x01\x20\x03(\x0b2\
    \x16.dfproto.BasicUnitInfoR\x05value\"\x0e\n\x0cListSquadsIn\">\n\rListS\
    quadsOut\x12-\n\x05value\x18\x01\x20\x03(\x0b2\x17.dfproto.BasicSquadInf\
    oR\x05value\"B\n\x0fSetUnitLaborsIn\x12/\n\x06change\x18\x01\x20\x03(\
    \x0b2\x17.dfproto.UnitLaborStateR\x06changeB\x02H\x03b\x06proto2\
";

/// `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(1);
            deps.push(super::Basic::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(10);
            messages.push(GetWorldInfoOut::generated_message_descriptor_data());
            messages.push(ListEnumsOut::generated_message_descriptor_data());
            messages.push(ListJobSkillsOut::generated_message_descriptor_data());
            messages.push(ListMaterialsIn::generated_message_descriptor_data());
            messages.push(ListMaterialsOut::generated_message_descriptor_data());
            messages.push(ListUnitsIn::generated_message_descriptor_data());
            messages.push(ListUnitsOut::generated_message_descriptor_data());
            messages.push(ListSquadsIn::generated_message_descriptor_data());
            messages.push(ListSquadsOut::generated_message_descriptor_data());
            messages.push(SetUnitLaborsIn::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(1);
            enums.push(get_world_info_out::Mode::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}