smmdb 1.4.2

// This file is generated by rust-protobuf 2.18.0. Do not edit
// @generated

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

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

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `SMM2Course.proto`

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct SMM2Course {
    // message fields
    pub version: u32,
    pub header: ::protobuf::SingularPtrField<SMM2CourseHeader>,
    pub course_area: ::protobuf::SingularPtrField<SMM2CourseArea>,
    pub course_sub_area: ::protobuf::SingularPtrField<SMM2CourseArea>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint32 version = 1;


    pub fn get_version(&self) -> u32 {
        self.version
    }
    pub fn clear_version(&mut self) {
        self.version = 0;
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: u32) {
        self.version = v;
    }

    // .smmdb.SMM2CourseHeader header = 2;


    pub fn get_header(&self) -> &SMM2CourseHeader {
        self.header.as_ref().unwrap_or_else(|| <SMM2CourseHeader as ::protobuf::Message>::default_instance())
    }
    pub fn clear_header(&mut self) {
        self.header.clear();
    }

    pub fn has_header(&self) -> bool {
        self.header.is_some()
    }

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

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

    // Take field
    pub fn take_header(&mut self) -> SMM2CourseHeader {
        self.header.take().unwrap_or_else(|| SMM2CourseHeader::new())
    }

    // .smmdb.SMM2CourseArea course_area = 3;


    pub fn get_course_area(&self) -> &SMM2CourseArea {
        self.course_area.as_ref().unwrap_or_else(|| <SMM2CourseArea as ::protobuf::Message>::default_instance())
    }
    pub fn clear_course_area(&mut self) {
        self.course_area.clear();
    }

    pub fn has_course_area(&self) -> bool {
        self.course_area.is_some()
    }

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

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

    // Take field
    pub fn take_course_area(&mut self) -> SMM2CourseArea {
        self.course_area.take().unwrap_or_else(|| SMM2CourseArea::new())
    }

    // .smmdb.SMM2CourseArea course_sub_area = 4;


    pub fn get_course_sub_area(&self) -> &SMM2CourseArea {
        self.course_sub_area.as_ref().unwrap_or_else(|| <SMM2CourseArea as ::protobuf::Message>::default_instance())
    }
    pub fn clear_course_sub_area(&mut self) {
        self.course_sub_area.clear();
    }

    pub fn has_course_sub_area(&self) -> bool {
        self.course_sub_area.is_some()
    }

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

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

    // Take field
    pub fn take_course_sub_area(&mut self) -> SMM2CourseArea {
        self.course_sub_area.take().unwrap_or_else(|| SMM2CourseArea::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.version = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.header)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.course_area)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.course_sub_area)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.version != 0 {
            my_size += ::protobuf::rt::value_size(1, self.version, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.header.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.course_area.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.course_sub_area.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.version != 0 {
            os.write_uint32(1, self.version)?;
        }
        if let Some(ref v) = self.header.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.course_area.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.course_sub_area.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "version",
                |m: &SMM2Course| { &m.version },
                |m: &mut SMM2Course| { &mut m.version },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SMM2CourseHeader>>(
                "header",
                |m: &SMM2Course| { &m.header },
                |m: &mut SMM2Course| { &mut m.header },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SMM2CourseArea>>(
                "course_area",
                |m: &SMM2Course| { &m.course_area },
                |m: &mut SMM2Course| { &mut m.course_area },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SMM2CourseArea>>(
                "course_sub_area",
                |m: &SMM2Course| { &m.course_sub_area },
                |m: &mut SMM2Course| { &mut m.course_sub_area },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SMM2Course>(
                "SMM2Course",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for SMM2Course {
    fn clear(&mut self) {
        self.version = 0;
        self.header.clear();
        self.course_area.clear();
        self.course_sub_area.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct SMM2CourseHeader {
    // message fields
    pub modified: u64,
    pub title: ::std::string::String,
    pub description: ::std::string::String,
    pub start_y: u32,
    pub finish_y: u32,
    pub finish_x: u32,
    pub time: u32,
    pub game_style: SMM2CourseHeader_GameStyle,
    pub clear_condition_type: SMM2CourseHeader_ClearConditionType,
    pub clear_condition: u32,
    pub clear_condition_amount: u32,
    pub clear_check_tries: u32,
    pub clear_check_time: u32,
    pub game_version: u32,
    pub management_flags: u32,
    pub creation_id: u32,
    pub upload_id: u64,
    pub completion_version: u32,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 modified = 1;


    pub fn get_modified(&self) -> u64 {
        self.modified
    }
    pub fn clear_modified(&mut self) {
        self.modified = 0;
    }

    // Param is passed by value, moved
    pub fn set_modified(&mut self, v: u64) {
        self.modified = v;
    }

    // string title = 2;


    pub fn get_title(&self) -> &str {
        &self.title
    }
    pub fn clear_title(&mut self) {
        self.title.clear();
    }

    // Param is passed by value, moved
    pub fn set_title(&mut self, v: ::std::string::String) {
        self.title = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_title(&mut self) -> &mut ::std::string::String {
        &mut self.title
    }

    // Take field
    pub fn take_title(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.title, ::std::string::String::new())
    }

    // string description = 3;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

    // Param is passed by value, moved
    pub fn set_description(&mut self, v: ::std::string::String) {
        self.description = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_description(&mut self) -> &mut ::std::string::String {
        &mut self.description
    }

    // Take field
    pub fn take_description(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.description, ::std::string::String::new())
    }

    // uint32 start_y = 4;


    pub fn get_start_y(&self) -> u32 {
        self.start_y
    }
    pub fn clear_start_y(&mut self) {
        self.start_y = 0;
    }

    // Param is passed by value, moved
    pub fn set_start_y(&mut self, v: u32) {
        self.start_y = v;
    }

    // uint32 finish_y = 5;


    pub fn get_finish_y(&self) -> u32 {
        self.finish_y
    }
    pub fn clear_finish_y(&mut self) {
        self.finish_y = 0;
    }

    // Param is passed by value, moved
    pub fn set_finish_y(&mut self, v: u32) {
        self.finish_y = v;
    }

    // uint32 finish_x = 6;


    pub fn get_finish_x(&self) -> u32 {
        self.finish_x
    }
    pub fn clear_finish_x(&mut self) {
        self.finish_x = 0;
    }

    // Param is passed by value, moved
    pub fn set_finish_x(&mut self, v: u32) {
        self.finish_x = v;
    }

    // uint32 time = 7;


    pub fn get_time(&self) -> u32 {
        self.time
    }
    pub fn clear_time(&mut self) {
        self.time = 0;
    }

    // Param is passed by value, moved
    pub fn set_time(&mut self, v: u32) {
        self.time = v;
    }

    // .smmdb.SMM2CourseHeader.GameStyle game_style = 8;


    pub fn get_game_style(&self) -> SMM2CourseHeader_GameStyle {
        self.game_style
    }
    pub fn clear_game_style(&mut self) {
        self.game_style = SMM2CourseHeader_GameStyle::M1;
    }

    // Param is passed by value, moved
    pub fn set_game_style(&mut self, v: SMM2CourseHeader_GameStyle) {
        self.game_style = v;
    }

    // .smmdb.SMM2CourseHeader.ClearConditionType clear_condition_type = 9;


    pub fn get_clear_condition_type(&self) -> SMM2CourseHeader_ClearConditionType {
        self.clear_condition_type
    }
    pub fn clear_clear_condition_type(&mut self) {
        self.clear_condition_type = SMM2CourseHeader_ClearConditionType::NONE;
    }

    // Param is passed by value, moved
    pub fn set_clear_condition_type(&mut self, v: SMM2CourseHeader_ClearConditionType) {
        self.clear_condition_type = v;
    }

    // uint32 clear_condition = 10;


    pub fn get_clear_condition(&self) -> u32 {
        self.clear_condition
    }
    pub fn clear_clear_condition(&mut self) {
        self.clear_condition = 0;
    }

    // Param is passed by value, moved
    pub fn set_clear_condition(&mut self, v: u32) {
        self.clear_condition = v;
    }

    // uint32 clear_condition_amount = 11;


    pub fn get_clear_condition_amount(&self) -> u32 {
        self.clear_condition_amount
    }
    pub fn clear_clear_condition_amount(&mut self) {
        self.clear_condition_amount = 0;
    }

    // Param is passed by value, moved
    pub fn set_clear_condition_amount(&mut self, v: u32) {
        self.clear_condition_amount = v;
    }

    // uint32 clear_check_tries = 12;


    pub fn get_clear_check_tries(&self) -> u32 {
        self.clear_check_tries
    }
    pub fn clear_clear_check_tries(&mut self) {
        self.clear_check_tries = 0;
    }

    // Param is passed by value, moved
    pub fn set_clear_check_tries(&mut self, v: u32) {
        self.clear_check_tries = v;
    }

    // uint32 clear_check_time = 13;


    pub fn get_clear_check_time(&self) -> u32 {
        self.clear_check_time
    }
    pub fn clear_clear_check_time(&mut self) {
        self.clear_check_time = 0;
    }

    // Param is passed by value, moved
    pub fn set_clear_check_time(&mut self, v: u32) {
        self.clear_check_time = v;
    }

    // uint32 game_version = 14;


    pub fn get_game_version(&self) -> u32 {
        self.game_version
    }
    pub fn clear_game_version(&mut self) {
        self.game_version = 0;
    }

    // Param is passed by value, moved
    pub fn set_game_version(&mut self, v: u32) {
        self.game_version = v;
    }

    // uint32 management_flags = 15;


    pub fn get_management_flags(&self) -> u32 {
        self.management_flags
    }
    pub fn clear_management_flags(&mut self) {
        self.management_flags = 0;
    }

    // Param is passed by value, moved
    pub fn set_management_flags(&mut self, v: u32) {
        self.management_flags = v;
    }

    // uint32 creation_id = 16;


    pub fn get_creation_id(&self) -> u32 {
        self.creation_id
    }
    pub fn clear_creation_id(&mut self) {
        self.creation_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_creation_id(&mut self, v: u32) {
        self.creation_id = v;
    }

    // uint64 upload_id = 17;


    pub fn get_upload_id(&self) -> u64 {
        self.upload_id
    }
    pub fn clear_upload_id(&mut self) {
        self.upload_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_upload_id(&mut self, v: u64) {
        self.upload_id = v;
    }

    // uint32 completion_version = 18;


    pub fn get_completion_version(&self) -> u32 {
        self.completion_version
    }
    pub fn clear_completion_version(&mut self) {
        self.completion_version = 0;
    }

    // Param is passed by value, moved
    pub fn set_completion_version(&mut self, v: u32) {
        self.completion_version = v;
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.modified = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.title)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.start_y = tmp;
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.finish_y = tmp;
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.finish_x = tmp;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.time = tmp;
                },
                8 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.game_style, 8, &mut self.unknown_fields)?
                },
                9 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.clear_condition_type, 9, &mut self.unknown_fields)?
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.clear_condition = tmp;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.clear_condition_amount = tmp;
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.clear_check_tries = tmp;
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.clear_check_time = tmp;
                },
                14 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.game_version = tmp;
                },
                15 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.management_flags = tmp;
                },
                16 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.creation_id = tmp;
                },
                17 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.upload_id = tmp;
                },
                18 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.completion_version = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.modified != 0 {
            my_size += ::protobuf::rt::value_size(1, self.modified, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.title.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.title);
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.description);
        }
        if self.start_y != 0 {
            my_size += ::protobuf::rt::value_size(4, self.start_y, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.finish_y != 0 {
            my_size += ::protobuf::rt::value_size(5, self.finish_y, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.finish_x != 0 {
            my_size += ::protobuf::rt::value_size(6, self.finish_x, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.time != 0 {
            my_size += ::protobuf::rt::value_size(7, self.time, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.game_style != SMM2CourseHeader_GameStyle::M1 {
            my_size += ::protobuf::rt::enum_size(8, self.game_style);
        }
        if self.clear_condition_type != SMM2CourseHeader_ClearConditionType::NONE {
            my_size += ::protobuf::rt::enum_size(9, self.clear_condition_type);
        }
        if self.clear_condition != 0 {
            my_size += ::protobuf::rt::value_size(10, self.clear_condition, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.clear_condition_amount != 0 {
            my_size += ::protobuf::rt::value_size(11, self.clear_condition_amount, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.clear_check_tries != 0 {
            my_size += ::protobuf::rt::value_size(12, self.clear_check_tries, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.clear_check_time != 0 {
            my_size += ::protobuf::rt::value_size(13, self.clear_check_time, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.game_version != 0 {
            my_size += ::protobuf::rt::value_size(14, self.game_version, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.management_flags != 0 {
            my_size += ::protobuf::rt::value_size(15, self.management_flags, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.creation_id != 0 {
            my_size += ::protobuf::rt::value_size(16, self.creation_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.upload_id != 0 {
            my_size += ::protobuf::rt::value_size(17, self.upload_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.completion_version != 0 {
            my_size += ::protobuf::rt::value_size(18, self.completion_version, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.modified != 0 {
            os.write_uint64(1, self.modified)?;
        }
        if !self.title.is_empty() {
            os.write_string(2, &self.title)?;
        }
        if !self.description.is_empty() {
            os.write_string(3, &self.description)?;
        }
        if self.start_y != 0 {
            os.write_uint32(4, self.start_y)?;
        }
        if self.finish_y != 0 {
            os.write_uint32(5, self.finish_y)?;
        }
        if self.finish_x != 0 {
            os.write_uint32(6, self.finish_x)?;
        }
        if self.time != 0 {
            os.write_uint32(7, self.time)?;
        }
        if self.game_style != SMM2CourseHeader_GameStyle::M1 {
            os.write_enum(8, ::protobuf::ProtobufEnum::value(&self.game_style))?;
        }
        if self.clear_condition_type != SMM2CourseHeader_ClearConditionType::NONE {
            os.write_enum(9, ::protobuf::ProtobufEnum::value(&self.clear_condition_type))?;
        }
        if self.clear_condition != 0 {
            os.write_uint32(10, self.clear_condition)?;
        }
        if self.clear_condition_amount != 0 {
            os.write_uint32(11, self.clear_condition_amount)?;
        }
        if self.clear_check_tries != 0 {
            os.write_uint32(12, self.clear_check_tries)?;
        }
        if self.clear_check_time != 0 {
            os.write_uint32(13, self.clear_check_time)?;
        }
        if self.game_version != 0 {
            os.write_uint32(14, self.game_version)?;
        }
        if self.management_flags != 0 {
            os.write_uint32(15, self.management_flags)?;
        }
        if self.creation_id != 0 {
            os.write_uint32(16, self.creation_id)?;
        }
        if self.upload_id != 0 {
            os.write_uint64(17, self.upload_id)?;
        }
        if self.completion_version != 0 {
            os.write_uint32(18, self.completion_version)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "modified",
                |m: &SMM2CourseHeader| { &m.modified },
                |m: &mut SMM2CourseHeader| { &mut m.modified },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "title",
                |m: &SMM2CourseHeader| { &m.title },
                |m: &mut SMM2CourseHeader| { &mut m.title },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "description",
                |m: &SMM2CourseHeader| { &m.description },
                |m: &mut SMM2CourseHeader| { &mut m.description },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "start_y",
                |m: &SMM2CourseHeader| { &m.start_y },
                |m: &mut SMM2CourseHeader| { &mut m.start_y },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "finish_y",
                |m: &SMM2CourseHeader| { &m.finish_y },
                |m: &mut SMM2CourseHeader| { &mut m.finish_y },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "finish_x",
                |m: &SMM2CourseHeader| { &m.finish_x },
                |m: &mut SMM2CourseHeader| { &mut m.finish_x },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "time",
                |m: &SMM2CourseHeader| { &m.time },
                |m: &mut SMM2CourseHeader| { &mut m.time },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseHeader_GameStyle>>(
                "game_style",
                |m: &SMM2CourseHeader| { &m.game_style },
                |m: &mut SMM2CourseHeader| { &mut m.game_style },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseHeader_ClearConditionType>>(
                "clear_condition_type",
                |m: &SMM2CourseHeader| { &m.clear_condition_type },
                |m: &mut SMM2CourseHeader| { &mut m.clear_condition_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "clear_condition",
                |m: &SMM2CourseHeader| { &m.clear_condition },
                |m: &mut SMM2CourseHeader| { &mut m.clear_condition },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "clear_condition_amount",
                |m: &SMM2CourseHeader| { &m.clear_condition_amount },
                |m: &mut SMM2CourseHeader| { &mut m.clear_condition_amount },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "clear_check_tries",
                |m: &SMM2CourseHeader| { &m.clear_check_tries },
                |m: &mut SMM2CourseHeader| { &mut m.clear_check_tries },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "clear_check_time",
                |m: &SMM2CourseHeader| { &m.clear_check_time },
                |m: &mut SMM2CourseHeader| { &mut m.clear_check_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "game_version",
                |m: &SMM2CourseHeader| { &m.game_version },
                |m: &mut SMM2CourseHeader| { &mut m.game_version },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "management_flags",
                |m: &SMM2CourseHeader| { &m.management_flags },
                |m: &mut SMM2CourseHeader| { &mut m.management_flags },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "creation_id",
                |m: &SMM2CourseHeader| { &m.creation_id },
                |m: &mut SMM2CourseHeader| { &mut m.creation_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "upload_id",
                |m: &SMM2CourseHeader| { &m.upload_id },
                |m: &mut SMM2CourseHeader| { &mut m.upload_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "completion_version",
                |m: &SMM2CourseHeader| { &m.completion_version },
                |m: &mut SMM2CourseHeader| { &mut m.completion_version },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SMM2CourseHeader>(
                "SMM2CourseHeader",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for SMM2CourseHeader {
    fn clear(&mut self) {
        self.modified = 0;
        self.title.clear();
        self.description.clear();
        self.start_y = 0;
        self.finish_y = 0;
        self.finish_x = 0;
        self.time = 0;
        self.game_style = SMM2CourseHeader_GameStyle::M1;
        self.clear_condition_type = SMM2CourseHeader_ClearConditionType::NONE;
        self.clear_condition = 0;
        self.clear_condition_amount = 0;
        self.clear_check_tries = 0;
        self.clear_check_time = 0;
        self.game_version = 0;
        self.management_flags = 0;
        self.creation_id = 0;
        self.upload_id = 0;
        self.completion_version = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseHeader_GameStyle {
    M1 = 0,
    M3 = 1,
    MW = 2,
    WU = 3,
    W3 = 4,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseHeader_GameStyle> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseHeader_GameStyle::M1),
            1 => ::std::option::Option::Some(SMM2CourseHeader_GameStyle::M3),
            2 => ::std::option::Option::Some(SMM2CourseHeader_GameStyle::MW),
            3 => ::std::option::Option::Some(SMM2CourseHeader_GameStyle::WU),
            4 => ::std::option::Option::Some(SMM2CourseHeader_GameStyle::W3),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseHeader_GameStyle] = &[
            SMM2CourseHeader_GameStyle::M1,
            SMM2CourseHeader_GameStyle::M3,
            SMM2CourseHeader_GameStyle::MW,
            SMM2CourseHeader_GameStyle::WU,
            SMM2CourseHeader_GameStyle::W3,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseHeader_GameStyle {
    fn default() -> Self {
        SMM2CourseHeader_GameStyle::M1
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseHeader_ClearConditionType {
    NONE = 0,
    PARTS = 1,
    STATUS = 2,
    ACTION = 3,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseHeader_ClearConditionType> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseHeader_ClearConditionType::NONE),
            1 => ::std::option::Option::Some(SMM2CourseHeader_ClearConditionType::PARTS),
            2 => ::std::option::Option::Some(SMM2CourseHeader_ClearConditionType::STATUS),
            3 => ::std::option::Option::Some(SMM2CourseHeader_ClearConditionType::ACTION),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseHeader_ClearConditionType] = &[
            SMM2CourseHeader_ClearConditionType::NONE,
            SMM2CourseHeader_ClearConditionType::PARTS,
            SMM2CourseHeader_ClearConditionType::STATUS,
            SMM2CourseHeader_ClearConditionType::ACTION,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseHeader_ClearConditionType {
    fn default() -> Self {
        SMM2CourseHeader_ClearConditionType::NONE
    }
}

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

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct SMM2CourseArea {
    // message fields
    pub course_theme: SMM2CourseArea_CourseTheme,
    pub auto_scroll: SMM2CourseArea_AutoScroll,
    pub screen_boundary: SMM2CourseArea_ScreenBoundary,
    pub orientation: SMM2CourseArea_Orientation,
    pub liquid_max: u32,
    pub liquid_mode: SMM2CourseArea_LiquidMode,
    pub liquid_speed: SMM2CourseArea_LiquidSpeed,
    pub liquid_min: u32,
    pub right_boundary: u32,
    pub top_boundary: u32,
    pub left_boundary: u32,
    pub bottom_boundary: u32,
    pub day_time: SMM2CourseArea_DayTime,
    pub object_count: u32,
    pub sound_effect_count: u32,
    pub snake_block_count: u32,
    pub clear_pipe_count: u32,
    pub piranha_creeper_count: u32,
    pub exclamation_block_count: u32,
    pub track_block_count: u32,
    pub tile_count: u32,
    pub track_count: u32,
    pub icicle_count: u32,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .smmdb.SMM2CourseArea.CourseTheme course_theme = 1;


    pub fn get_course_theme(&self) -> SMM2CourseArea_CourseTheme {
        self.course_theme
    }
    pub fn clear_course_theme(&mut self) {
        self.course_theme = SMM2CourseArea_CourseTheme::GROUND;
    }

    // Param is passed by value, moved
    pub fn set_course_theme(&mut self, v: SMM2CourseArea_CourseTheme) {
        self.course_theme = v;
    }

    // .smmdb.SMM2CourseArea.AutoScroll auto_scroll = 2;


    pub fn get_auto_scroll(&self) -> SMM2CourseArea_AutoScroll {
        self.auto_scroll
    }
    pub fn clear_auto_scroll(&mut self) {
        self.auto_scroll = SMM2CourseArea_AutoScroll::NONE;
    }

    // Param is passed by value, moved
    pub fn set_auto_scroll(&mut self, v: SMM2CourseArea_AutoScroll) {
        self.auto_scroll = v;
    }

    // .smmdb.SMM2CourseArea.ScreenBoundary screen_boundary = 3;


    pub fn get_screen_boundary(&self) -> SMM2CourseArea_ScreenBoundary {
        self.screen_boundary
    }
    pub fn clear_screen_boundary(&mut self) {
        self.screen_boundary = SMM2CourseArea_ScreenBoundary::ABOVE_LINE;
    }

    // Param is passed by value, moved
    pub fn set_screen_boundary(&mut self, v: SMM2CourseArea_ScreenBoundary) {
        self.screen_boundary = v;
    }

    // .smmdb.SMM2CourseArea.Orientation orientation = 4;


    pub fn get_orientation(&self) -> SMM2CourseArea_Orientation {
        self.orientation
    }
    pub fn clear_orientation(&mut self) {
        self.orientation = SMM2CourseArea_Orientation::HORIZONTAL;
    }

    // Param is passed by value, moved
    pub fn set_orientation(&mut self, v: SMM2CourseArea_Orientation) {
        self.orientation = v;
    }

    // uint32 liquid_max = 5;


    pub fn get_liquid_max(&self) -> u32 {
        self.liquid_max
    }
    pub fn clear_liquid_max(&mut self) {
        self.liquid_max = 0;
    }

    // Param is passed by value, moved
    pub fn set_liquid_max(&mut self, v: u32) {
        self.liquid_max = v;
    }

    // .smmdb.SMM2CourseArea.LiquidMode liquid_mode = 6;


    pub fn get_liquid_mode(&self) -> SMM2CourseArea_LiquidMode {
        self.liquid_mode
    }
    pub fn clear_liquid_mode(&mut self) {
        self.liquid_mode = SMM2CourseArea_LiquidMode::FIXED;
    }

    // Param is passed by value, moved
    pub fn set_liquid_mode(&mut self, v: SMM2CourseArea_LiquidMode) {
        self.liquid_mode = v;
    }

    // .smmdb.SMM2CourseArea.LiquidSpeed liquid_speed = 7;


    pub fn get_liquid_speed(&self) -> SMM2CourseArea_LiquidSpeed {
        self.liquid_speed
    }
    pub fn clear_liquid_speed(&mut self) {
        self.liquid_speed = SMM2CourseArea_LiquidSpeed::NONE;
    }

    // Param is passed by value, moved
    pub fn set_liquid_speed(&mut self, v: SMM2CourseArea_LiquidSpeed) {
        self.liquid_speed = v;
    }

    // uint32 liquid_min = 8;


    pub fn get_liquid_min(&self) -> u32 {
        self.liquid_min
    }
    pub fn clear_liquid_min(&mut self) {
        self.liquid_min = 0;
    }

    // Param is passed by value, moved
    pub fn set_liquid_min(&mut self, v: u32) {
        self.liquid_min = v;
    }

    // uint32 right_boundary = 9;


    pub fn get_right_boundary(&self) -> u32 {
        self.right_boundary
    }
    pub fn clear_right_boundary(&mut self) {
        self.right_boundary = 0;
    }

    // Param is passed by value, moved
    pub fn set_right_boundary(&mut self, v: u32) {
        self.right_boundary = v;
    }

    // uint32 top_boundary = 10;


    pub fn get_top_boundary(&self) -> u32 {
        self.top_boundary
    }
    pub fn clear_top_boundary(&mut self) {
        self.top_boundary = 0;
    }

    // Param is passed by value, moved
    pub fn set_top_boundary(&mut self, v: u32) {
        self.top_boundary = v;
    }

    // uint32 left_boundary = 11;


    pub fn get_left_boundary(&self) -> u32 {
        self.left_boundary
    }
    pub fn clear_left_boundary(&mut self) {
        self.left_boundary = 0;
    }

    // Param is passed by value, moved
    pub fn set_left_boundary(&mut self, v: u32) {
        self.left_boundary = v;
    }

    // uint32 bottom_boundary = 12;


    pub fn get_bottom_boundary(&self) -> u32 {
        self.bottom_boundary
    }
    pub fn clear_bottom_boundary(&mut self) {
        self.bottom_boundary = 0;
    }

    // Param is passed by value, moved
    pub fn set_bottom_boundary(&mut self, v: u32) {
        self.bottom_boundary = v;
    }

    // .smmdb.SMM2CourseArea.DayTime day_time = 13;


    pub fn get_day_time(&self) -> SMM2CourseArea_DayTime {
        self.day_time
    }
    pub fn clear_day_time(&mut self) {
        self.day_time = SMM2CourseArea_DayTime::DAY;
    }

    // Param is passed by value, moved
    pub fn set_day_time(&mut self, v: SMM2CourseArea_DayTime) {
        self.day_time = v;
    }

    // uint32 object_count = 14;


    pub fn get_object_count(&self) -> u32 {
        self.object_count
    }
    pub fn clear_object_count(&mut self) {
        self.object_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_object_count(&mut self, v: u32) {
        self.object_count = v;
    }

    // uint32 sound_effect_count = 15;


    pub fn get_sound_effect_count(&self) -> u32 {
        self.sound_effect_count
    }
    pub fn clear_sound_effect_count(&mut self) {
        self.sound_effect_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_sound_effect_count(&mut self, v: u32) {
        self.sound_effect_count = v;
    }

    // uint32 snake_block_count = 16;


    pub fn get_snake_block_count(&self) -> u32 {
        self.snake_block_count
    }
    pub fn clear_snake_block_count(&mut self) {
        self.snake_block_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_snake_block_count(&mut self, v: u32) {
        self.snake_block_count = v;
    }

    // uint32 clear_pipe_count = 17;


    pub fn get_clear_pipe_count(&self) -> u32 {
        self.clear_pipe_count
    }
    pub fn clear_clear_pipe_count(&mut self) {
        self.clear_pipe_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_clear_pipe_count(&mut self, v: u32) {
        self.clear_pipe_count = v;
    }

    // uint32 piranha_creeper_count = 18;


    pub fn get_piranha_creeper_count(&self) -> u32 {
        self.piranha_creeper_count
    }
    pub fn clear_piranha_creeper_count(&mut self) {
        self.piranha_creeper_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_piranha_creeper_count(&mut self, v: u32) {
        self.piranha_creeper_count = v;
    }

    // uint32 exclamation_block_count = 19;


    pub fn get_exclamation_block_count(&self) -> u32 {
        self.exclamation_block_count
    }
    pub fn clear_exclamation_block_count(&mut self) {
        self.exclamation_block_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_exclamation_block_count(&mut self, v: u32) {
        self.exclamation_block_count = v;
    }

    // uint32 track_block_count = 20;


    pub fn get_track_block_count(&self) -> u32 {
        self.track_block_count
    }
    pub fn clear_track_block_count(&mut self) {
        self.track_block_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_track_block_count(&mut self, v: u32) {
        self.track_block_count = v;
    }

    // uint32 tile_count = 21;


    pub fn get_tile_count(&self) -> u32 {
        self.tile_count
    }
    pub fn clear_tile_count(&mut self) {
        self.tile_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_tile_count(&mut self, v: u32) {
        self.tile_count = v;
    }

    // uint32 track_count = 22;


    pub fn get_track_count(&self) -> u32 {
        self.track_count
    }
    pub fn clear_track_count(&mut self) {
        self.track_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_track_count(&mut self, v: u32) {
        self.track_count = v;
    }

    // uint32 icicle_count = 23;


    pub fn get_icicle_count(&self) -> u32 {
        self.icicle_count
    }
    pub fn clear_icicle_count(&mut self) {
        self.icicle_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_icicle_count(&mut self, v: u32) {
        self.icicle_count = v;
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.course_theme, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.auto_scroll, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.screen_boundary, 3, &mut self.unknown_fields)?
                },
                4 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.orientation, 4, &mut self.unknown_fields)?
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.liquid_max = tmp;
                },
                6 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.liquid_mode, 6, &mut self.unknown_fields)?
                },
                7 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.liquid_speed, 7, &mut self.unknown_fields)?
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.liquid_min = tmp;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.right_boundary = tmp;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.top_boundary = tmp;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.left_boundary = tmp;
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.bottom_boundary = tmp;
                },
                13 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.day_time, 13, &mut self.unknown_fields)?
                },
                14 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.object_count = tmp;
                },
                15 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.sound_effect_count = tmp;
                },
                16 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.snake_block_count = tmp;
                },
                17 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.clear_pipe_count = tmp;
                },
                18 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.piranha_creeper_count = tmp;
                },
                19 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.exclamation_block_count = tmp;
                },
                20 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.track_block_count = tmp;
                },
                21 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.tile_count = tmp;
                },
                22 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.track_count = tmp;
                },
                23 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.icicle_count = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.course_theme != SMM2CourseArea_CourseTheme::GROUND {
            my_size += ::protobuf::rt::enum_size(1, self.course_theme);
        }
        if self.auto_scroll != SMM2CourseArea_AutoScroll::NONE {
            my_size += ::protobuf::rt::enum_size(2, self.auto_scroll);
        }
        if self.screen_boundary != SMM2CourseArea_ScreenBoundary::ABOVE_LINE {
            my_size += ::protobuf::rt::enum_size(3, self.screen_boundary);
        }
        if self.orientation != SMM2CourseArea_Orientation::HORIZONTAL {
            my_size += ::protobuf::rt::enum_size(4, self.orientation);
        }
        if self.liquid_max != 0 {
            my_size += ::protobuf::rt::value_size(5, self.liquid_max, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.liquid_mode != SMM2CourseArea_LiquidMode::FIXED {
            my_size += ::protobuf::rt::enum_size(6, self.liquid_mode);
        }
        if self.liquid_speed != SMM2CourseArea_LiquidSpeed::NONE {
            my_size += ::protobuf::rt::enum_size(7, self.liquid_speed);
        }
        if self.liquid_min != 0 {
            my_size += ::protobuf::rt::value_size(8, self.liquid_min, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.right_boundary != 0 {
            my_size += ::protobuf::rt::value_size(9, self.right_boundary, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.top_boundary != 0 {
            my_size += ::protobuf::rt::value_size(10, self.top_boundary, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.left_boundary != 0 {
            my_size += ::protobuf::rt::value_size(11, self.left_boundary, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.bottom_boundary != 0 {
            my_size += ::protobuf::rt::value_size(12, self.bottom_boundary, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.day_time != SMM2CourseArea_DayTime::DAY {
            my_size += ::protobuf::rt::enum_size(13, self.day_time);
        }
        if self.object_count != 0 {
            my_size += ::protobuf::rt::value_size(14, self.object_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.sound_effect_count != 0 {
            my_size += ::protobuf::rt::value_size(15, self.sound_effect_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.snake_block_count != 0 {
            my_size += ::protobuf::rt::value_size(16, self.snake_block_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.clear_pipe_count != 0 {
            my_size += ::protobuf::rt::value_size(17, self.clear_pipe_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.piranha_creeper_count != 0 {
            my_size += ::protobuf::rt::value_size(18, self.piranha_creeper_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.exclamation_block_count != 0 {
            my_size += ::protobuf::rt::value_size(19, self.exclamation_block_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.track_block_count != 0 {
            my_size += ::protobuf::rt::value_size(20, self.track_block_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.tile_count != 0 {
            my_size += ::protobuf::rt::value_size(21, self.tile_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.track_count != 0 {
            my_size += ::protobuf::rt::value_size(22, self.track_count, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.icicle_count != 0 {
            my_size += ::protobuf::rt::value_size(23, self.icicle_count, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.course_theme != SMM2CourseArea_CourseTheme::GROUND {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.course_theme))?;
        }
        if self.auto_scroll != SMM2CourseArea_AutoScroll::NONE {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.auto_scroll))?;
        }
        if self.screen_boundary != SMM2CourseArea_ScreenBoundary::ABOVE_LINE {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&self.screen_boundary))?;
        }
        if self.orientation != SMM2CourseArea_Orientation::HORIZONTAL {
            os.write_enum(4, ::protobuf::ProtobufEnum::value(&self.orientation))?;
        }
        if self.liquid_max != 0 {
            os.write_uint32(5, self.liquid_max)?;
        }
        if self.liquid_mode != SMM2CourseArea_LiquidMode::FIXED {
            os.write_enum(6, ::protobuf::ProtobufEnum::value(&self.liquid_mode))?;
        }
        if self.liquid_speed != SMM2CourseArea_LiquidSpeed::NONE {
            os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.liquid_speed))?;
        }
        if self.liquid_min != 0 {
            os.write_uint32(8, self.liquid_min)?;
        }
        if self.right_boundary != 0 {
            os.write_uint32(9, self.right_boundary)?;
        }
        if self.top_boundary != 0 {
            os.write_uint32(10, self.top_boundary)?;
        }
        if self.left_boundary != 0 {
            os.write_uint32(11, self.left_boundary)?;
        }
        if self.bottom_boundary != 0 {
            os.write_uint32(12, self.bottom_boundary)?;
        }
        if self.day_time != SMM2CourseArea_DayTime::DAY {
            os.write_enum(13, ::protobuf::ProtobufEnum::value(&self.day_time))?;
        }
        if self.object_count != 0 {
            os.write_uint32(14, self.object_count)?;
        }
        if self.sound_effect_count != 0 {
            os.write_uint32(15, self.sound_effect_count)?;
        }
        if self.snake_block_count != 0 {
            os.write_uint32(16, self.snake_block_count)?;
        }
        if self.clear_pipe_count != 0 {
            os.write_uint32(17, self.clear_pipe_count)?;
        }
        if self.piranha_creeper_count != 0 {
            os.write_uint32(18, self.piranha_creeper_count)?;
        }
        if self.exclamation_block_count != 0 {
            os.write_uint32(19, self.exclamation_block_count)?;
        }
        if self.track_block_count != 0 {
            os.write_uint32(20, self.track_block_count)?;
        }
        if self.tile_count != 0 {
            os.write_uint32(21, self.tile_count)?;
        }
        if self.track_count != 0 {
            os.write_uint32(22, self.track_count)?;
        }
        if self.icicle_count != 0 {
            os.write_uint32(23, self.icicle_count)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_CourseTheme>>(
                "course_theme",
                |m: &SMM2CourseArea| { &m.course_theme },
                |m: &mut SMM2CourseArea| { &mut m.course_theme },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_AutoScroll>>(
                "auto_scroll",
                |m: &SMM2CourseArea| { &m.auto_scroll },
                |m: &mut SMM2CourseArea| { &mut m.auto_scroll },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_ScreenBoundary>>(
                "screen_boundary",
                |m: &SMM2CourseArea| { &m.screen_boundary },
                |m: &mut SMM2CourseArea| { &mut m.screen_boundary },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_Orientation>>(
                "orientation",
                |m: &SMM2CourseArea| { &m.orientation },
                |m: &mut SMM2CourseArea| { &mut m.orientation },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "liquid_max",
                |m: &SMM2CourseArea| { &m.liquid_max },
                |m: &mut SMM2CourseArea| { &mut m.liquid_max },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_LiquidMode>>(
                "liquid_mode",
                |m: &SMM2CourseArea| { &m.liquid_mode },
                |m: &mut SMM2CourseArea| { &mut m.liquid_mode },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_LiquidSpeed>>(
                "liquid_speed",
                |m: &SMM2CourseArea| { &m.liquid_speed },
                |m: &mut SMM2CourseArea| { &mut m.liquid_speed },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "liquid_min",
                |m: &SMM2CourseArea| { &m.liquid_min },
                |m: &mut SMM2CourseArea| { &mut m.liquid_min },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "right_boundary",
                |m: &SMM2CourseArea| { &m.right_boundary },
                |m: &mut SMM2CourseArea| { &mut m.right_boundary },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "top_boundary",
                |m: &SMM2CourseArea| { &m.top_boundary },
                |m: &mut SMM2CourseArea| { &mut m.top_boundary },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "left_boundary",
                |m: &SMM2CourseArea| { &m.left_boundary },
                |m: &mut SMM2CourseArea| { &mut m.left_boundary },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "bottom_boundary",
                |m: &SMM2CourseArea| { &m.bottom_boundary },
                |m: &mut SMM2CourseArea| { &mut m.bottom_boundary },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<SMM2CourseArea_DayTime>>(
                "day_time",
                |m: &SMM2CourseArea| { &m.day_time },
                |m: &mut SMM2CourseArea| { &mut m.day_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "object_count",
                |m: &SMM2CourseArea| { &m.object_count },
                |m: &mut SMM2CourseArea| { &mut m.object_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "sound_effect_count",
                |m: &SMM2CourseArea| { &m.sound_effect_count },
                |m: &mut SMM2CourseArea| { &mut m.sound_effect_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "snake_block_count",
                |m: &SMM2CourseArea| { &m.snake_block_count },
                |m: &mut SMM2CourseArea| { &mut m.snake_block_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "clear_pipe_count",
                |m: &SMM2CourseArea| { &m.clear_pipe_count },
                |m: &mut SMM2CourseArea| { &mut m.clear_pipe_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "piranha_creeper_count",
                |m: &SMM2CourseArea| { &m.piranha_creeper_count },
                |m: &mut SMM2CourseArea| { &mut m.piranha_creeper_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "exclamation_block_count",
                |m: &SMM2CourseArea| { &m.exclamation_block_count },
                |m: &mut SMM2CourseArea| { &mut m.exclamation_block_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "track_block_count",
                |m: &SMM2CourseArea| { &m.track_block_count },
                |m: &mut SMM2CourseArea| { &mut m.track_block_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "tile_count",
                |m: &SMM2CourseArea| { &m.tile_count },
                |m: &mut SMM2CourseArea| { &mut m.tile_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "track_count",
                |m: &SMM2CourseArea| { &m.track_count },
                |m: &mut SMM2CourseArea| { &mut m.track_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "icicle_count",
                |m: &SMM2CourseArea| { &m.icicle_count },
                |m: &mut SMM2CourseArea| { &mut m.icicle_count },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SMM2CourseArea>(
                "SMM2CourseArea",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for SMM2CourseArea {
    fn clear(&mut self) {
        self.course_theme = SMM2CourseArea_CourseTheme::GROUND;
        self.auto_scroll = SMM2CourseArea_AutoScroll::NONE;
        self.screen_boundary = SMM2CourseArea_ScreenBoundary::ABOVE_LINE;
        self.orientation = SMM2CourseArea_Orientation::HORIZONTAL;
        self.liquid_max = 0;
        self.liquid_mode = SMM2CourseArea_LiquidMode::FIXED;
        self.liquid_speed = SMM2CourseArea_LiquidSpeed::NONE;
        self.liquid_min = 0;
        self.right_boundary = 0;
        self.top_boundary = 0;
        self.left_boundary = 0;
        self.bottom_boundary = 0;
        self.day_time = SMM2CourseArea_DayTime::DAY;
        self.object_count = 0;
        self.sound_effect_count = 0;
        self.snake_block_count = 0;
        self.clear_pipe_count = 0;
        self.piranha_creeper_count = 0;
        self.exclamation_block_count = 0;
        self.track_block_count = 0;
        self.tile_count = 0;
        self.track_count = 0;
        self.icicle_count = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_CourseTheme {
    GROUND = 0,
    UNDERGROUND = 1,
    CASTLE = 2,
    AIRSHIP = 3,
    UNDERWATER = 4,
    GHOUST_HOUSE = 5,
    SNOW = 6,
    DESERT = 7,
    SKY = 8,
    FOREST = 9,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_CourseTheme> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::GROUND),
            1 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::UNDERGROUND),
            2 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::CASTLE),
            3 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::AIRSHIP),
            4 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::UNDERWATER),
            5 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::GHOUST_HOUSE),
            6 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::SNOW),
            7 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::DESERT),
            8 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::SKY),
            9 => ::std::option::Option::Some(SMM2CourseArea_CourseTheme::FOREST),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_CourseTheme] = &[
            SMM2CourseArea_CourseTheme::GROUND,
            SMM2CourseArea_CourseTheme::UNDERGROUND,
            SMM2CourseArea_CourseTheme::CASTLE,
            SMM2CourseArea_CourseTheme::AIRSHIP,
            SMM2CourseArea_CourseTheme::UNDERWATER,
            SMM2CourseArea_CourseTheme::GHOUST_HOUSE,
            SMM2CourseArea_CourseTheme::SNOW,
            SMM2CourseArea_CourseTheme::DESERT,
            SMM2CourseArea_CourseTheme::SKY,
            SMM2CourseArea_CourseTheme::FOREST,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_CourseTheme {
    fn default() -> Self {
        SMM2CourseArea_CourseTheme::GROUND
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_AutoScroll {
    NONE = 0,
    SLOW = 1,
    MEDIUM = 2,
    FAST = 3,
    CUSTOM = 4,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_AutoScroll> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_AutoScroll::NONE),
            1 => ::std::option::Option::Some(SMM2CourseArea_AutoScroll::SLOW),
            2 => ::std::option::Option::Some(SMM2CourseArea_AutoScroll::MEDIUM),
            3 => ::std::option::Option::Some(SMM2CourseArea_AutoScroll::FAST),
            4 => ::std::option::Option::Some(SMM2CourseArea_AutoScroll::CUSTOM),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_AutoScroll] = &[
            SMM2CourseArea_AutoScroll::NONE,
            SMM2CourseArea_AutoScroll::SLOW,
            SMM2CourseArea_AutoScroll::MEDIUM,
            SMM2CourseArea_AutoScroll::FAST,
            SMM2CourseArea_AutoScroll::CUSTOM,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_AutoScroll {
    fn default() -> Self {
        SMM2CourseArea_AutoScroll::NONE
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_ScreenBoundary {
    ABOVE_LINE = 0,
    UNDER_LINE = 1,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_ScreenBoundary> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_ScreenBoundary::ABOVE_LINE),
            1 => ::std::option::Option::Some(SMM2CourseArea_ScreenBoundary::UNDER_LINE),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_ScreenBoundary] = &[
            SMM2CourseArea_ScreenBoundary::ABOVE_LINE,
            SMM2CourseArea_ScreenBoundary::UNDER_LINE,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_ScreenBoundary {
    fn default() -> Self {
        SMM2CourseArea_ScreenBoundary::ABOVE_LINE
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_Orientation {
    HORIZONTAL = 0,
    VERTICAL = 1,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_Orientation> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_Orientation::HORIZONTAL),
            1 => ::std::option::Option::Some(SMM2CourseArea_Orientation::VERTICAL),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_Orientation] = &[
            SMM2CourseArea_Orientation::HORIZONTAL,
            SMM2CourseArea_Orientation::VERTICAL,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_Orientation {
    fn default() -> Self {
        SMM2CourseArea_Orientation::HORIZONTAL
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_LiquidMode {
    FIXED = 0,
    ONE_WAY = 1,
    OSCILLATING = 2,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_LiquidMode> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_LiquidMode::FIXED),
            1 => ::std::option::Option::Some(SMM2CourseArea_LiquidMode::ONE_WAY),
            2 => ::std::option::Option::Some(SMM2CourseArea_LiquidMode::OSCILLATING),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_LiquidMode] = &[
            SMM2CourseArea_LiquidMode::FIXED,
            SMM2CourseArea_LiquidMode::ONE_WAY,
            SMM2CourseArea_LiquidMode::OSCILLATING,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_LiquidMode {
    fn default() -> Self {
        SMM2CourseArea_LiquidMode::FIXED
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_LiquidSpeed {
    NONE = 0,
    SLOW = 1,
    MEDIUM = 2,
    FAST = 3,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_LiquidSpeed> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_LiquidSpeed::NONE),
            1 => ::std::option::Option::Some(SMM2CourseArea_LiquidSpeed::SLOW),
            2 => ::std::option::Option::Some(SMM2CourseArea_LiquidSpeed::MEDIUM),
            3 => ::std::option::Option::Some(SMM2CourseArea_LiquidSpeed::FAST),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_LiquidSpeed] = &[
            SMM2CourseArea_LiquidSpeed::NONE,
            SMM2CourseArea_LiquidSpeed::SLOW,
            SMM2CourseArea_LiquidSpeed::MEDIUM,
            SMM2CourseArea_LiquidSpeed::FAST,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_LiquidSpeed {
    fn default() -> Self {
        SMM2CourseArea_LiquidSpeed::NONE
    }
}

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum SMM2CourseArea_DayTime {
    DAY = 0,
    UNKNOWN0 = 1,
    NIGHT = 2,
    UNKNOWN1 = 3,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<SMM2CourseArea_DayTime> {
        match value {
            0 => ::std::option::Option::Some(SMM2CourseArea_DayTime::DAY),
            1 => ::std::option::Option::Some(SMM2CourseArea_DayTime::UNKNOWN0),
            2 => ::std::option::Option::Some(SMM2CourseArea_DayTime::NIGHT),
            3 => ::std::option::Option::Some(SMM2CourseArea_DayTime::UNKNOWN1),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [SMM2CourseArea_DayTime] = &[
            SMM2CourseArea_DayTime::DAY,
            SMM2CourseArea_DayTime::UNKNOWN0,
            SMM2CourseArea_DayTime::NIGHT,
            SMM2CourseArea_DayTime::UNKNOWN1,
        ];
        values
    }

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

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

impl ::std::default::Default for SMM2CourseArea_DayTime {
    fn default() -> Self {
        SMM2CourseArea_DayTime::DAY
    }
}

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x10SMM2Course.proto\x12\x05smmdb\"\xd8\x01\n\nSMM2Course\x12\x1a\n\
    \x07version\x18\x01\x20\x01(\rR\x07versionB\0\x121\n\x06header\x18\x02\
    \x20\x01(\x0b2\x17.smmdb.SMM2CourseHeaderR\x06headerB\0\x128\n\x0bcourse\
    _area\x18\x03\x20\x01(\x0b2\x15.smmdb.SMM2CourseAreaR\ncourseAreaB\0\x12\
    ?\n\x0fcourse_sub_area\x18\x04\x20\x01(\x0b2\x15.smmdb.SMM2CourseAreaR\r\
    courseSubAreaB\0:\0\"\xfb\x06\n\x10SMM2CourseHeader\x12\x1c\n\x08modifie\
    d\x18\x01\x20\x01(\x04R\x08modifiedB\0\x12\x16\n\x05title\x18\x02\x20\
    \x01(\tR\x05titleB\0\x12\"\n\x0bdescription\x18\x03\x20\x01(\tR\x0bdescr\
    iptionB\0\x12\x19\n\x07start_y\x18\x04\x20\x01(\rR\x06startYB\0\x12\x1b\
    \n\x08finish_y\x18\x05\x20\x01(\rR\x07finishYB\0\x12\x1b\n\x08finish_x\
    \x18\x06\x20\x01(\rR\x07finishXB\0\x12\x14\n\x04time\x18\x07\x20\x01(\rR\
    \x04timeB\0\x12B\n\ngame_style\x18\x08\x20\x01(\x0e2!.smmdb.SMM2CourseHe\
    ader.GameStyleR\tgameStyleB\0\x12^\n\x14clear_condition_type\x18\t\x20\
    \x01(\x0e2*.smmdb.SMM2CourseHeader.ClearConditionTypeR\x12clearCondition\
    TypeB\0\x12)\n\x0fclear_condition\x18\n\x20\x01(\rR\x0eclearConditionB\0\
    \x126\n\x16clear_condition_amount\x18\x0b\x20\x01(\rR\x14clearConditionA\
    mountB\0\x12,\n\x11clear_check_tries\x18\x0c\x20\x01(\rR\x0fclearCheckTr\
    iesB\0\x12*\n\x10clear_check_time\x18\r\x20\x01(\rR\x0eclearCheckTimeB\0\
    \x12#\n\x0cgame_version\x18\x0e\x20\x01(\rR\x0bgameVersionB\0\x12+\n\x10\
    management_flags\x18\x0f\x20\x01(\rR\x0fmanagementFlagsB\0\x12!\n\x0bcre\
    ation_id\x18\x10\x20\x01(\rR\ncreationIdB\0\x12\x1d\n\tupload_id\x18\x11\
    \x20\x01(\x04R\x08uploadIdB\0\x12/\n\x12completion_version\x18\x12\x20\
    \x01(\rR\x11completionVersionB\0\"5\n\tGameStyle\x12\x06\n\x02M1\x10\0\
    \x12\x06\n\x02M3\x10\x01\x12\x06\n\x02MW\x10\x02\x12\x06\n\x02WU\x10\x03\
    \x12\x06\n\x02W3\x10\x04\x1a\0\"C\n\x12ClearConditionType\x12\x08\n\x04N\
    ONE\x10\0\x12\t\n\x05PARTS\x10\x01\x12\n\n\x06STATUS\x10\x02\x12\n\n\x06\
    ACTION\x10\x03\x1a\0:\0\"\x87\r\n\x0eSMM2CourseArea\x12F\n\x0ccourse_the\
    me\x18\x01\x20\x01(\x0e2!.smmdb.SMM2CourseArea.CourseThemeR\x0bcourseThe\
    meB\0\x12C\n\x0bauto_scroll\x18\x02\x20\x01(\x0e2\x20.smmdb.SMM2CourseAr\
    ea.AutoScrollR\nautoScrollB\0\x12O\n\x0fscreen_boundary\x18\x03\x20\x01(\
    \x0e2$.smmdb.SMM2CourseArea.ScreenBoundaryR\x0escreenBoundaryB\0\x12E\n\
    \x0borientation\x18\x04\x20\x01(\x0e2!.smmdb.SMM2CourseArea.OrientationR\
    \x0borientationB\0\x12\x1f\n\nliquid_max\x18\x05\x20\x01(\rR\tliquidMaxB\
    \0\x12C\n\x0bliquid_mode\x18\x06\x20\x01(\x0e2\x20.smmdb.SMM2CourseArea.\
    LiquidModeR\nliquidModeB\0\x12F\n\x0cliquid_speed\x18\x07\x20\x01(\x0e2!\
    .smmdb.SMM2CourseArea.LiquidSpeedR\x0bliquidSpeedB\0\x12\x1f\n\nliquid_m\
    in\x18\x08\x20\x01(\rR\tliquidMinB\0\x12'\n\x0eright_boundary\x18\t\x20\
    \x01(\rR\rrightBoundaryB\0\x12#\n\x0ctop_boundary\x18\n\x20\x01(\rR\x0bt\
    opBoundaryB\0\x12%\n\rleft_boundary\x18\x0b\x20\x01(\rR\x0cleftBoundaryB\
    \0\x12)\n\x0fbottom_boundary\x18\x0c\x20\x01(\rR\x0ebottomBoundaryB\0\
    \x12:\n\x08day_time\x18\r\x20\x01(\x0e2\x1d.smmdb.SMM2CourseArea.DayTime\
    R\x07dayTimeB\0\x12#\n\x0cobject_count\x18\x0e\x20\x01(\rR\x0bobjectCoun\
    tB\0\x12.\n\x12sound_effect_count\x18\x0f\x20\x01(\rR\x10soundEffectCoun\
    tB\0\x12,\n\x11snake_block_count\x18\x10\x20\x01(\rR\x0fsnakeBlockCountB\
    \0\x12*\n\x10clear_pipe_count\x18\x11\x20\x01(\rR\x0eclearPipeCountB\0\
    \x124\n\x15piranha_creeper_count\x18\x12\x20\x01(\rR\x13piranhaCreeperCo\
    untB\0\x128\n\x17exclamation_block_count\x18\x13\x20\x01(\rR\x15exclamat\
    ionBlockCountB\0\x12,\n\x11track_block_count\x18\x14\x20\x01(\rR\x0ftrac\
    kBlockCountB\0\x12\x1f\n\ntile_count\x18\x15\x20\x01(\rR\ttileCountB\0\
    \x12!\n\x0btrack_count\x18\x16\x20\x01(\rR\ntrackCountB\0\x12#\n\x0cicic\
    le_count\x18\x17\x20\x01(\rR\x0bicicleCountB\0\"\x92\x01\n\x0bCourseThem\
    e\x12\n\n\x06GROUND\x10\0\x12\x0f\n\x0bUNDERGROUND\x10\x01\x12\n\n\x06CA\
    STLE\x10\x02\x12\x0b\n\x07AIRSHIP\x10\x03\x12\x0e\n\nUNDERWATER\x10\x04\
    \x12\x10\n\x0cGHOUST_HOUSE\x10\x05\x12\x08\n\x04SNOW\x10\x06\x12\n\n\x06\
    DESERT\x10\x07\x12\x07\n\x03SKY\x10\x08\x12\n\n\x06FOREST\x10\t\x1a\0\"D\
    \n\nAutoScroll\x12\x08\n\x04NONE\x10\0\x12\x08\n\x04SLOW\x10\x01\x12\n\n\
    \x06MEDIUM\x10\x02\x12\x08\n\x04FAST\x10\x03\x12\n\n\x06CUSTOM\x10\x04\
    \x1a\0\"2\n\x0eScreenBoundary\x12\x0e\n\nABOVE_LINE\x10\0\x12\x0e\n\nUND\
    ER_LINE\x10\x01\x1a\0\"-\n\x0bOrientation\x12\x0e\n\nHORIZONTAL\x10\0\
    \x12\x0c\n\x08VERTICAL\x10\x01\x1a\0\"7\n\nLiquidMode\x12\t\n\x05FIXED\
    \x10\0\x12\x0b\n\x07ONE_WAY\x10\x01\x12\x0f\n\x0bOSCILLATING\x10\x02\x1a\
    \0\"9\n\x0bLiquidSpeed\x12\x08\n\x04NONE\x10\0\x12\x08\n\x04SLOW\x10\x01\
    \x12\n\n\x06MEDIUM\x10\x02\x12\x08\n\x04FAST\x10\x03\x1a\0\";\n\x07DayTi\
    me\x12\x07\n\x03DAY\x10\0\x12\x0c\n\x08UNKNOWN0\x10\x01\x12\t\n\x05NIGHT\
    \x10\x02\x12\x0c\n\x08UNKNOWN1\x10\x03\x1a\0:\0B\0b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}