protobuf 0.0.3

// This file is generated. Do not edit

#![allow(dead_code)]
#![allow(non_camel_case_types)]
#![allow(non_upper_case_globals)]
#![allow(unused_imports)]


#[deriving(Clone,PartialEq,Default)]
pub struct FileDescriptorSet {
    file: ::protobuf::RepeatedField<FileDescriptorProto>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> FileDescriptorSet {
    pub fn new() -> FileDescriptorSet {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static FileDescriptorSet {
        static mut instance: ::protobuf::lazy::Lazy<FileDescriptorSet> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FileDescriptorSet };
        unsafe {
            instance.get(|| {
                FileDescriptorSet {
                    file: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated .google.protobuf.FileDescriptorProto file = 1;

    pub fn clear_file(&mut self) {
        self.file.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_file(&'a mut self) -> &'a mut ::protobuf::RepeatedField<FileDescriptorProto> {
        &mut self.file
    }

    pub fn get_file(&'a self) -> &'a [FileDescriptorProto] {
        self.file.as_slice()
    }
}

impl ::protobuf::Message for FileDescriptorSet {
    fn new() -> FileDescriptorSet {
        FileDescriptorSet::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.file.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.file.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        for v in self.file.iter() {
            try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<FileDescriptorSet>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<FileDescriptorSet>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorSet_file_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorSet>) });
                ::protobuf::reflect::MessageDescriptor::new::<FileDescriptorSet>(
                    "FileDescriptorSet",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<FileDescriptorSet>()
    }
}

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

impl ::std::fmt::Show for FileDescriptorSet {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct FileDescriptorSet_file_acc_type;
static FileDescriptorSet_file_acc: FileDescriptorSet_file_acc_type = FileDescriptorSet_file_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorSet> for FileDescriptorSet_file_acc_type {
    fn name(&self) -> &'static str {
        "file"
    }

    fn len_field(&self, m: &FileDescriptorSet) -> uint {
        m.get_file().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FileDescriptorSet, index: uint) -> &'a ::protobuf::Message {
        &m.get_file()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct FileDescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    package: ::protobuf::SingularField<::std::string::String>,
    dependency: ::protobuf::RepeatedField<::std::string::String>,
    public_dependency: ::std::vec::Vec<i32>,
    weak_dependency: ::std::vec::Vec<i32>,
    message_type: ::protobuf::RepeatedField<DescriptorProto>,
    enum_type: ::protobuf::RepeatedField<EnumDescriptorProto>,
    service: ::protobuf::RepeatedField<ServiceDescriptorProto>,
    extension: ::protobuf::RepeatedField<FieldDescriptorProto>,
    options: ::protobuf::SingularPtrField<FileOptions>,
    source_code_info: ::protobuf::SingularPtrField<SourceCodeInfo>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> FileDescriptorProto {
    pub fn new() -> FileDescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static FileDescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<FileDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FileDescriptorProto };
        unsafe {
            instance.get(|| {
                FileDescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    package: ::protobuf::SingularField::none(),
                    dependency: ::protobuf::RepeatedField::new(),
                    public_dependency: ::std::vec::Vec::new(),
                    weak_dependency: ::std::vec::Vec::new(),
                    message_type: ::protobuf::RepeatedField::new(),
                    enum_type: ::protobuf::RepeatedField::new(),
                    service: ::protobuf::RepeatedField::new(),
                    extension: ::protobuf::RepeatedField::new(),
                    options: ::protobuf::SingularPtrField::none(),
                    source_code_info: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // optional string package = 2;

    pub fn clear_package(&mut self) {
        self.package.clear();
    }

    pub fn has_package(&self) -> bool {
        self.package.is_some()
    }

    // Param is passed by value, moved
    pub fn set_package(&mut self, v: ::std::string::String) {
        self.package = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_package(&'a mut self) -> &'a mut ::std::string::String {
        if self.package.is_none() {
            self.package.set_default();
        };
        self.package.as_mut().unwrap()
    }

    pub fn get_package(&'a self) -> &'a str {
        match self.package.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // repeated string dependency = 3;

    pub fn clear_dependency(&mut self) {
        self.dependency.clear();
    }

    // Param is passed by value, moved
    pub fn set_dependency(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.dependency = v;
    }

    // Mutable pointer to the field.
    pub fn mut_dependency(&'a mut self) -> &'a mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.dependency
    }

    pub fn get_dependency(&'a self) -> &'a [::std::string::String] {
        self.dependency.as_slice()
    }

    // repeated int32 public_dependency = 10;

    pub fn clear_public_dependency(&mut self) {
        self.public_dependency.clear();
    }

    // Param is passed by value, moved
    pub fn set_public_dependency(&mut self, v: ::std::vec::Vec<i32>) {
        self.public_dependency = v;
    }

    // Mutable pointer to the field.
    pub fn mut_public_dependency(&'a mut self) -> &'a mut ::std::vec::Vec<i32> {
        &mut self.public_dependency
    }

    pub fn get_public_dependency(&'a self) -> &'a [i32] {
        self.public_dependency.as_slice()
    }

    // repeated int32 weak_dependency = 11;

    pub fn clear_weak_dependency(&mut self) {
        self.weak_dependency.clear();
    }

    // Param is passed by value, moved
    pub fn set_weak_dependency(&mut self, v: ::std::vec::Vec<i32>) {
        self.weak_dependency = v;
    }

    // Mutable pointer to the field.
    pub fn mut_weak_dependency(&'a mut self) -> &'a mut ::std::vec::Vec<i32> {
        &mut self.weak_dependency
    }

    pub fn get_weak_dependency(&'a self) -> &'a [i32] {
        self.weak_dependency.as_slice()
    }

    // repeated .google.protobuf.DescriptorProto message_type = 4;

    pub fn clear_message_type(&mut self) {
        self.message_type.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_message_type(&'a mut self) -> &'a mut ::protobuf::RepeatedField<DescriptorProto> {
        &mut self.message_type
    }

    pub fn get_message_type(&'a self) -> &'a [DescriptorProto] {
        self.message_type.as_slice()
    }

    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;

    pub fn clear_enum_type(&mut self) {
        self.enum_type.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_enum_type(&'a mut self) -> &'a mut ::protobuf::RepeatedField<EnumDescriptorProto> {
        &mut self.enum_type
    }

    pub fn get_enum_type(&'a self) -> &'a [EnumDescriptorProto] {
        self.enum_type.as_slice()
    }

    // repeated .google.protobuf.ServiceDescriptorProto service = 6;

    pub fn clear_service(&mut self) {
        self.service.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_service(&'a mut self) -> &'a mut ::protobuf::RepeatedField<ServiceDescriptorProto> {
        &mut self.service
    }

    pub fn get_service(&'a self) -> &'a [ServiceDescriptorProto] {
        self.service.as_slice()
    }

    // repeated .google.protobuf.FieldDescriptorProto extension = 7;

    pub fn clear_extension(&mut self) {
        self.extension.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_extension(&'a mut self) -> &'a mut ::protobuf::RepeatedField<FieldDescriptorProto> {
        &mut self.extension
    }

    pub fn get_extension(&'a self) -> &'a [FieldDescriptorProto] {
        self.extension.as_slice()
    }

    // optional .google.protobuf.FileOptions options = 8;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a FileOptions {
        self.options.as_ref().unwrap_or_else(|| FileOptions::default_instance())
    }

    // optional .google.protobuf.SourceCodeInfo source_code_info = 9;

    pub fn clear_source_code_info(&mut self) {
        self.source_code_info.clear();
    }

    pub fn has_source_code_info(&self) -> bool {
        self.source_code_info.is_some()
    }

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

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

    pub fn get_source_code_info(&'a self) -> &'a SourceCodeInfo {
        self.source_code_info.as_ref().unwrap_or_else(|| SourceCodeInfo::default_instance())
    }
}

impl ::protobuf::Message for FileDescriptorProto {
    fn new() -> FileDescriptorProto {
        FileDescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.package.set_default();
                    try!(is.read_string_into(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.dependency.push_default();
                    try!(is.read_string_into(tmp))
                },
                10 => {
                    if wire_type == ::protobuf::wire_format::WireTypeLengthDelimited {
                        let len = try!(is.read_raw_varint32());
                        let old_limit = is.push_limit(len);
                        while !try!(is.eof()) {
                            self.public_dependency.push(try!(is.read_int32()));
                        }
                        is.pop_limit(old_limit);
                    } else {
                        if wire_type != ::protobuf::wire_format::WireTypeVarint {
                            return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                        };
                        self.public_dependency.push(try!(is.read_int32()));
                    }
                },
                11 => {
                    if wire_type == ::protobuf::wire_format::WireTypeLengthDelimited {
                        let len = try!(is.read_raw_varint32());
                        let old_limit = is.push_limit(len);
                        while !try!(is.eof()) {
                            self.weak_dependency.push(try!(is.read_int32()));
                        }
                        is.pop_limit(old_limit);
                    } else {
                        if wire_type != ::protobuf::wire_format::WireTypeVarint {
                            return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                        };
                        self.weak_dependency.push(try!(is.read_int32()));
                    }
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.message_type.push_default();
                    try!(is.merge_message(tmp))
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.enum_type.push_default();
                    try!(is.merge_message(tmp))
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.service.push_default();
                    try!(is.merge_message(tmp))
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.extension.push_default();
                    try!(is.merge_message(tmp))
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.source_code_info.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.package.iter() {
            my_size += ::protobuf::rt::string_size(2, value.as_slice());
        };
        for value in self.dependency.iter() {
            my_size += ::protobuf::rt::string_size(3, value.as_slice());
        };
        for value in self.public_dependency.iter() {
            my_size += ::protobuf::rt::value_size(10, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in self.weak_dependency.iter() {
            my_size += ::protobuf::rt::value_size(11, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in self.message_type.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.enum_type.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.service.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.extension.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.source_code_info.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        match self.package.as_ref() {
            Some(v) => {
                try!(os.write_string(2, v.as_slice()));
            },
            None => {},
        };
        for v in self.dependency.iter() {
            try!(os.write_string(3, v.as_slice()));
        };
        for v in self.public_dependency.iter() {
            try!(os.write_int32(10, *v));
        };
        for v in self.weak_dependency.iter() {
            try!(os.write_int32(11, *v));
        };
        for v in self.message_type.iter() {
            try!(os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.enum_type.iter() {
            try!(os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.service.iter() {
            try!(os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.extension.iter() {
            try!(os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        match self.source_code_info.as_ref() {
            Some(v) => {
                try!(os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<FileDescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_package_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_dependency_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_public_dependency_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_weak_dependency_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_message_type_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_enum_type_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_service_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_extension_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FileDescriptorProto_source_code_info_acc as &'static ::protobuf::reflect::FieldAccessor<FileDescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<FileDescriptorProto>(
                    "FileDescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<FileDescriptorProto>()
    }
}

impl ::protobuf::Clear for FileDescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_package();
        self.clear_dependency();
        self.clear_public_dependency();
        self.clear_weak_dependency();
        self.clear_message_type();
        self.clear_enum_type();
        self.clear_service();
        self.clear_extension();
        self.clear_options();
        self.clear_source_code_info();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for FileDescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct FileDescriptorProto_name_acc_type;
static FileDescriptorProto_name_acc: FileDescriptorProto_name_acc_type = FileDescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &FileDescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a FileDescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_package_acc_type;
static FileDescriptorProto_package_acc: FileDescriptorProto_package_acc_type = FileDescriptorProto_package_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_package_acc_type {
    fn name(&self) -> &'static str {
        "package"
    }

    fn has_field(&self, m: &FileDescriptorProto) -> bool {
        m.has_package()
    }

    fn get_str<'a>(&self, m: &'a FileDescriptorProto) -> &'a str {
        m.get_package()
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_dependency_acc_type;
static FileDescriptorProto_dependency_acc: FileDescriptorProto_dependency_acc_type = FileDescriptorProto_dependency_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_dependency_acc_type {
    fn name(&self) -> &'static str {
        "dependency"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_dependency().len()
    }

    fn get_rep_str<'a>(&self, m: &'a FileDescriptorProto) -> &'a [::std::string::String] {
        m.get_dependency()
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_public_dependency_acc_type;
static FileDescriptorProto_public_dependency_acc: FileDescriptorProto_public_dependency_acc_type = FileDescriptorProto_public_dependency_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_public_dependency_acc_type {
    fn name(&self) -> &'static str {
        "public_dependency"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_public_dependency().len()
    }

    fn get_rep_i32<'a>(&self, m: &'a FileDescriptorProto) -> &'a [i32] {
        m.get_public_dependency()
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_weak_dependency_acc_type;
static FileDescriptorProto_weak_dependency_acc: FileDescriptorProto_weak_dependency_acc_type = FileDescriptorProto_weak_dependency_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_weak_dependency_acc_type {
    fn name(&self) -> &'static str {
        "weak_dependency"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_weak_dependency().len()
    }

    fn get_rep_i32<'a>(&self, m: &'a FileDescriptorProto) -> &'a [i32] {
        m.get_weak_dependency()
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_message_type_acc_type;
static FileDescriptorProto_message_type_acc: FileDescriptorProto_message_type_acc_type = FileDescriptorProto_message_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_message_type_acc_type {
    fn name(&self) -> &'static str {
        "message_type"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_message_type().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FileDescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_message_type()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_enum_type_acc_type;
static FileDescriptorProto_enum_type_acc: FileDescriptorProto_enum_type_acc_type = FileDescriptorProto_enum_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_enum_type_acc_type {
    fn name(&self) -> &'static str {
        "enum_type"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_enum_type().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FileDescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_enum_type()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_service_acc_type;
static FileDescriptorProto_service_acc: FileDescriptorProto_service_acc_type = FileDescriptorProto_service_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_service_acc_type {
    fn name(&self) -> &'static str {
        "service"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_service().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FileDescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_service()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_extension_acc_type;
static FileDescriptorProto_extension_acc: FileDescriptorProto_extension_acc_type = FileDescriptorProto_extension_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_extension_acc_type {
    fn name(&self) -> &'static str {
        "extension"
    }

    fn len_field(&self, m: &FileDescriptorProto) -> uint {
        m.get_extension().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FileDescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_extension()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_options_acc_type;
static FileDescriptorProto_options_acc: FileDescriptorProto_options_acc_type = FileDescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &FileDescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a FileDescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct FileDescriptorProto_source_code_info_acc_type;
static FileDescriptorProto_source_code_info_acc: FileDescriptorProto_source_code_info_acc_type = FileDescriptorProto_source_code_info_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileDescriptorProto> for FileDescriptorProto_source_code_info_acc_type {
    fn name(&self) -> &'static str {
        "source_code_info"
    }

    fn has_field(&self, m: &FileDescriptorProto) -> bool {
        m.has_source_code_info()
    }

    fn get_message<'a>(&self, m: &'a FileDescriptorProto) -> &'a ::protobuf::Message {
        m.get_source_code_info() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct DescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    field: ::protobuf::RepeatedField<FieldDescriptorProto>,
    extension: ::protobuf::RepeatedField<FieldDescriptorProto>,
    nested_type: ::protobuf::RepeatedField<DescriptorProto>,
    enum_type: ::protobuf::RepeatedField<EnumDescriptorProto>,
    extension_range: ::protobuf::RepeatedField<DescriptorProto_ExtensionRange>,
    options: ::protobuf::SingularPtrField<MessageOptions>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> DescriptorProto {
    pub fn new() -> DescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static DescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<DescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const DescriptorProto };
        unsafe {
            instance.get(|| {
                DescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    field: ::protobuf::RepeatedField::new(),
                    extension: ::protobuf::RepeatedField::new(),
                    nested_type: ::protobuf::RepeatedField::new(),
                    enum_type: ::protobuf::RepeatedField::new(),
                    extension_range: ::protobuf::RepeatedField::new(),
                    options: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // repeated .google.protobuf.FieldDescriptorProto field = 2;

    pub fn clear_field(&mut self) {
        self.field.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_field(&'a mut self) -> &'a mut ::protobuf::RepeatedField<FieldDescriptorProto> {
        &mut self.field
    }

    pub fn get_field(&'a self) -> &'a [FieldDescriptorProto] {
        self.field.as_slice()
    }

    // repeated .google.protobuf.FieldDescriptorProto extension = 6;

    pub fn clear_extension(&mut self) {
        self.extension.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_extension(&'a mut self) -> &'a mut ::protobuf::RepeatedField<FieldDescriptorProto> {
        &mut self.extension
    }

    pub fn get_extension(&'a self) -> &'a [FieldDescriptorProto] {
        self.extension.as_slice()
    }

    // repeated .google.protobuf.DescriptorProto nested_type = 3;

    pub fn clear_nested_type(&mut self) {
        self.nested_type.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_nested_type(&'a mut self) -> &'a mut ::protobuf::RepeatedField<DescriptorProto> {
        &mut self.nested_type
    }

    pub fn get_nested_type(&'a self) -> &'a [DescriptorProto] {
        self.nested_type.as_slice()
    }

    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;

    pub fn clear_enum_type(&mut self) {
        self.enum_type.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_enum_type(&'a mut self) -> &'a mut ::protobuf::RepeatedField<EnumDescriptorProto> {
        &mut self.enum_type
    }

    pub fn get_enum_type(&'a self) -> &'a [EnumDescriptorProto] {
        self.enum_type.as_slice()
    }

    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;

    pub fn clear_extension_range(&mut self) {
        self.extension_range.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_extension_range(&'a mut self) -> &'a mut ::protobuf::RepeatedField<DescriptorProto_ExtensionRange> {
        &mut self.extension_range
    }

    pub fn get_extension_range(&'a self) -> &'a [DescriptorProto_ExtensionRange] {
        self.extension_range.as_slice()
    }

    // optional .google.protobuf.MessageOptions options = 7;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a MessageOptions {
        self.options.as_ref().unwrap_or_else(|| MessageOptions::default_instance())
    }
}

impl ::protobuf::Message for DescriptorProto {
    fn new() -> DescriptorProto {
        DescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.field.push_default();
                    try!(is.merge_message(tmp))
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.extension.push_default();
                    try!(is.merge_message(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.nested_type.push_default();
                    try!(is.merge_message(tmp))
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.enum_type.push_default();
                    try!(is.merge_message(tmp))
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.extension_range.push_default();
                    try!(is.merge_message(tmp))
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.field.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.extension.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.nested_type.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.enum_type.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.extension_range.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        for v in self.field.iter() {
            try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.extension.iter() {
            try!(os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.nested_type.iter() {
            try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.enum_type.iter() {
            try!(os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        for v in self.extension_range.iter() {
            try!(os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<DescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<DescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_field_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_extension_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_nested_type_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_enum_type_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_extension_range_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<DescriptorProto>(
                    "DescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<DescriptorProto>()
    }
}

impl ::protobuf::Clear for DescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_field();
        self.clear_extension();
        self.clear_nested_type();
        self.clear_enum_type();
        self.clear_extension_range();
        self.clear_options();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for DescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct DescriptorProto_name_acc_type;
static DescriptorProto_name_acc: DescriptorProto_name_acc_type = DescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &DescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a DescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_field_acc_type;
static DescriptorProto_field_acc: DescriptorProto_field_acc_type = DescriptorProto_field_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_field_acc_type {
    fn name(&self) -> &'static str {
        "field"
    }

    fn len_field(&self, m: &DescriptorProto) -> uint {
        m.get_field().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a DescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_field()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_extension_acc_type;
static DescriptorProto_extension_acc: DescriptorProto_extension_acc_type = DescriptorProto_extension_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_extension_acc_type {
    fn name(&self) -> &'static str {
        "extension"
    }

    fn len_field(&self, m: &DescriptorProto) -> uint {
        m.get_extension().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a DescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_extension()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_nested_type_acc_type;
static DescriptorProto_nested_type_acc: DescriptorProto_nested_type_acc_type = DescriptorProto_nested_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_nested_type_acc_type {
    fn name(&self) -> &'static str {
        "nested_type"
    }

    fn len_field(&self, m: &DescriptorProto) -> uint {
        m.get_nested_type().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a DescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_nested_type()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_enum_type_acc_type;
static DescriptorProto_enum_type_acc: DescriptorProto_enum_type_acc_type = DescriptorProto_enum_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_enum_type_acc_type {
    fn name(&self) -> &'static str {
        "enum_type"
    }

    fn len_field(&self, m: &DescriptorProto) -> uint {
        m.get_enum_type().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a DescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_enum_type()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_extension_range_acc_type;
static DescriptorProto_extension_range_acc: DescriptorProto_extension_range_acc_type = DescriptorProto_extension_range_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_extension_range_acc_type {
    fn name(&self) -> &'static str {
        "extension_range"
    }

    fn len_field(&self, m: &DescriptorProto) -> uint {
        m.get_extension_range().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a DescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_extension_range()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_options_acc_type;
static DescriptorProto_options_acc: DescriptorProto_options_acc_type = DescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto> for DescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &DescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a DescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct DescriptorProto_ExtensionRange {
    start: ::std::option::Option<i32>,
    end: ::std::option::Option<i32>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> DescriptorProto_ExtensionRange {
    pub fn new() -> DescriptorProto_ExtensionRange {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static DescriptorProto_ExtensionRange {
        static mut instance: ::protobuf::lazy::Lazy<DescriptorProto_ExtensionRange> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const DescriptorProto_ExtensionRange };
        unsafe {
            instance.get(|| {
                DescriptorProto_ExtensionRange {
                    start: ::std::option::None,
                    end: ::std::option::None,
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional int32 start = 1;

    pub fn clear_start(&mut self) {
        self.start = None;
    }

    pub fn has_start(&self) -> bool {
        self.start.is_some()
    }

    // Param is passed by value, moved
    pub fn set_start(&mut self, v: i32) {
        self.start = Some(v);
    }

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

    // optional int32 end = 2;

    pub fn clear_end(&mut self) {
        self.end = None;
    }

    pub fn has_end(&self) -> bool {
        self.end.is_some()
    }

    // Param is passed by value, moved
    pub fn set_end(&mut self, v: i32) {
        self.end = Some(v);
    }

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

impl ::protobuf::Message for DescriptorProto_ExtensionRange {
    fn new() -> DescriptorProto_ExtensionRange {
        DescriptorProto_ExtensionRange::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_int32());
                    self.start = Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_int32());
                    self.end = Some(tmp);
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.start.iter() {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in self.end.iter() {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    #[allow(unused_variables)]
    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.start {
            Some(v) => {
                try!(os.write_int32(1, v));
            },
            None => {},
        };
        match self.end {
            Some(v) => {
                try!(os.write_int32(2, v));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<DescriptorProto_ExtensionRange>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<DescriptorProto_ExtensionRange>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_ExtensionRange_start_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto_ExtensionRange>) });
                fields.push(unsafe { ::std::mem::transmute(&DescriptorProto_ExtensionRange_end_acc as &'static ::protobuf::reflect::FieldAccessor<DescriptorProto_ExtensionRange>) });
                ::protobuf::reflect::MessageDescriptor::new::<DescriptorProto_ExtensionRange>(
                    "DescriptorProto_ExtensionRange",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<DescriptorProto_ExtensionRange>()
    }
}

impl ::protobuf::Clear for DescriptorProto_ExtensionRange {
    fn clear(&mut self) {
        self.clear_start();
        self.clear_end();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for DescriptorProto_ExtensionRange {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct DescriptorProto_ExtensionRange_start_acc_type;
static DescriptorProto_ExtensionRange_start_acc: DescriptorProto_ExtensionRange_start_acc_type = DescriptorProto_ExtensionRange_start_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto_ExtensionRange> for DescriptorProto_ExtensionRange_start_acc_type {
    fn name(&self) -> &'static str {
        "start"
    }

    fn has_field(&self, m: &DescriptorProto_ExtensionRange) -> bool {
        m.has_start()
    }

    fn get_i32(&self, m: &DescriptorProto_ExtensionRange) -> i32 {
        m.get_start()
    }
}

#[allow(non_camel_case_types)]
struct DescriptorProto_ExtensionRange_end_acc_type;
static DescriptorProto_ExtensionRange_end_acc: DescriptorProto_ExtensionRange_end_acc_type = DescriptorProto_ExtensionRange_end_acc_type;

impl ::protobuf::reflect::FieldAccessor<DescriptorProto_ExtensionRange> for DescriptorProto_ExtensionRange_end_acc_type {
    fn name(&self) -> &'static str {
        "end"
    }

    fn has_field(&self, m: &DescriptorProto_ExtensionRange) -> bool {
        m.has_end()
    }

    fn get_i32(&self, m: &DescriptorProto_ExtensionRange) -> i32 {
        m.get_end()
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct FieldDescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    number: ::std::option::Option<i32>,
    label: ::std::option::Option<FieldDescriptorProto_Label>,
    field_type: ::std::option::Option<FieldDescriptorProto_Type>,
    type_name: ::protobuf::SingularField<::std::string::String>,
    extendee: ::protobuf::SingularField<::std::string::String>,
    default_value: ::protobuf::SingularField<::std::string::String>,
    options: ::protobuf::SingularPtrField<FieldOptions>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> FieldDescriptorProto {
    pub fn new() -> FieldDescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static FieldDescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<FieldDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FieldDescriptorProto };
        unsafe {
            instance.get(|| {
                FieldDescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    number: ::std::option::None,
                    label: ::std::option::None,
                    field_type: ::std::option::None,
                    type_name: ::protobuf::SingularField::none(),
                    extendee: ::protobuf::SingularField::none(),
                    default_value: ::protobuf::SingularField::none(),
                    options: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // optional int32 number = 3;

    pub fn clear_number(&mut self) {
        self.number = None;
    }

    pub fn has_number(&self) -> bool {
        self.number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number(&mut self, v: i32) {
        self.number = Some(v);
    }

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

    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;

    pub fn clear_label(&mut self) {
        self.label = None;
    }

    pub fn has_label(&self) -> bool {
        self.label.is_some()
    }

    // Param is passed by value, moved
    pub fn set_label(&mut self, v: FieldDescriptorProto_Label) {
        self.label = Some(v);
    }

    pub fn get_label(&self) -> FieldDescriptorProto_Label {
        self.label.unwrap_or(FieldDescriptorProto_Label::LABEL_OPTIONAL)
    }

    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;

    pub fn clear_field_type(&mut self) {
        self.field_type = None;
    }

    pub fn has_field_type(&self) -> bool {
        self.field_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_field_type(&mut self, v: FieldDescriptorProto_Type) {
        self.field_type = Some(v);
    }

    pub fn get_field_type(&self) -> FieldDescriptorProto_Type {
        self.field_type.unwrap_or(FieldDescriptorProto_Type::TYPE_DOUBLE)
    }

    // optional string type_name = 6;

    pub fn clear_type_name(&mut self) {
        self.type_name.clear();
    }

    pub fn has_type_name(&self) -> bool {
        self.type_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type_name(&mut self, v: ::std::string::String) {
        self.type_name = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_type_name(&'a mut self) -> &'a mut ::std::string::String {
        if self.type_name.is_none() {
            self.type_name.set_default();
        };
        self.type_name.as_mut().unwrap()
    }

    pub fn get_type_name(&'a self) -> &'a str {
        match self.type_name.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional string extendee = 2;

    pub fn clear_extendee(&mut self) {
        self.extendee.clear();
    }

    pub fn has_extendee(&self) -> bool {
        self.extendee.is_some()
    }

    // Param is passed by value, moved
    pub fn set_extendee(&mut self, v: ::std::string::String) {
        self.extendee = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_extendee(&'a mut self) -> &'a mut ::std::string::String {
        if self.extendee.is_none() {
            self.extendee.set_default();
        };
        self.extendee.as_mut().unwrap()
    }

    pub fn get_extendee(&'a self) -> &'a str {
        match self.extendee.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional string default_value = 7;

    pub fn clear_default_value(&mut self) {
        self.default_value.clear();
    }

    pub fn has_default_value(&self) -> bool {
        self.default_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_default_value(&mut self, v: ::std::string::String) {
        self.default_value = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_default_value(&'a mut self) -> &'a mut ::std::string::String {
        if self.default_value.is_none() {
            self.default_value.set_default();
        };
        self.default_value.as_mut().unwrap()
    }

    pub fn get_default_value(&'a self) -> &'a str {
        match self.default_value.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional .google.protobuf.FieldOptions options = 8;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a FieldOptions {
        self.options.as_ref().unwrap_or_else(|| FieldOptions::default_instance())
    }
}

impl ::protobuf::Message for FieldDescriptorProto {
    fn new() -> FieldDescriptorProto {
        FieldDescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_int32());
                    self.number = Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = FieldDescriptorProto_Label::new(try!(is.read_int32()));
                    self.label = Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = FieldDescriptorProto_Type::new(try!(is.read_int32()));
                    self.field_type = Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.type_name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.extendee.set_default();
                    try!(is.read_string_into(tmp))
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.default_value.set_default();
                    try!(is.read_string_into(tmp))
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.number.iter() {
            my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in self.label.iter() {
            my_size += ::protobuf::rt::enum_size(4, *value);
        };
        for value in self.field_type.iter() {
            my_size += ::protobuf::rt::enum_size(5, *value);
        };
        for value in self.type_name.iter() {
            my_size += ::protobuf::rt::string_size(6, value.as_slice());
        };
        for value in self.extendee.iter() {
            my_size += ::protobuf::rt::string_size(2, value.as_slice());
        };
        for value in self.default_value.iter() {
            my_size += ::protobuf::rt::string_size(7, value.as_slice());
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        match self.number {
            Some(v) => {
                try!(os.write_int32(3, v));
            },
            None => {},
        };
        match self.label {
            Some(v) => {
                try!(os.write_enum(4, v as i32));
            },
            None => {},
        };
        match self.field_type {
            Some(v) => {
                try!(os.write_enum(5, v as i32));
            },
            None => {},
        };
        match self.type_name.as_ref() {
            Some(v) => {
                try!(os.write_string(6, v.as_slice()));
            },
            None => {},
        };
        match self.extendee.as_ref() {
            Some(v) => {
                try!(os.write_string(2, v.as_slice()));
            },
            None => {},
        };
        match self.default_value.as_ref() {
            Some(v) => {
                try!(os.write_string(7, v.as_slice()));
            },
            None => {},
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<FieldDescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_number_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_label_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_field_type_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_type_name_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_extendee_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_default_value_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldDescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<FieldDescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<FieldDescriptorProto>(
                    "FieldDescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<FieldDescriptorProto>()
    }
}

impl ::protobuf::Clear for FieldDescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_number();
        self.clear_label();
        self.clear_field_type();
        self.clear_type_name();
        self.clear_extendee();
        self.clear_default_value();
        self.clear_options();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for FieldDescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct FieldDescriptorProto_name_acc_type;
static FieldDescriptorProto_name_acc: FieldDescriptorProto_name_acc_type = FieldDescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a FieldDescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_number_acc_type;
static FieldDescriptorProto_number_acc: FieldDescriptorProto_number_acc_type = FieldDescriptorProto_number_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_number_acc_type {
    fn name(&self) -> &'static str {
        "number"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_number()
    }

    fn get_i32(&self, m: &FieldDescriptorProto) -> i32 {
        m.get_number()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_label_acc_type;
static FieldDescriptorProto_label_acc: FieldDescriptorProto_label_acc_type = FieldDescriptorProto_label_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_label_acc_type {
    fn name(&self) -> &'static str {
        "label"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_label()
    }

    fn get_enum<'a>(&self, m: &FieldDescriptorProto) -> &'static ::protobuf::reflect::EnumValueDescriptor {
        use protobuf::{ProtobufEnum};
        m.get_label().descriptor()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_field_type_acc_type;
static FieldDescriptorProto_field_type_acc: FieldDescriptorProto_field_type_acc_type = FieldDescriptorProto_field_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_field_type_acc_type {
    fn name(&self) -> &'static str {
        "field_type"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_field_type()
    }

    fn get_enum<'a>(&self, m: &FieldDescriptorProto) -> &'static ::protobuf::reflect::EnumValueDescriptor {
        use protobuf::{ProtobufEnum};
        m.get_field_type().descriptor()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_type_name_acc_type;
static FieldDescriptorProto_type_name_acc: FieldDescriptorProto_type_name_acc_type = FieldDescriptorProto_type_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_type_name_acc_type {
    fn name(&self) -> &'static str {
        "type_name"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_type_name()
    }

    fn get_str<'a>(&self, m: &'a FieldDescriptorProto) -> &'a str {
        m.get_type_name()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_extendee_acc_type;
static FieldDescriptorProto_extendee_acc: FieldDescriptorProto_extendee_acc_type = FieldDescriptorProto_extendee_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_extendee_acc_type {
    fn name(&self) -> &'static str {
        "extendee"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_extendee()
    }

    fn get_str<'a>(&self, m: &'a FieldDescriptorProto) -> &'a str {
        m.get_extendee()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_default_value_acc_type;
static FieldDescriptorProto_default_value_acc: FieldDescriptorProto_default_value_acc_type = FieldDescriptorProto_default_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_default_value_acc_type {
    fn name(&self) -> &'static str {
        "default_value"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_default_value()
    }

    fn get_str<'a>(&self, m: &'a FieldDescriptorProto) -> &'a str {
        m.get_default_value()
    }
}

#[allow(non_camel_case_types)]
struct FieldDescriptorProto_options_acc_type;
static FieldDescriptorProto_options_acc: FieldDescriptorProto_options_acc_type = FieldDescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldDescriptorProto> for FieldDescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &FieldDescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a FieldDescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Eq,Show)]
pub enum FieldDescriptorProto_Type {
    TYPE_DOUBLE = 1,
    TYPE_FLOAT = 2,
    TYPE_INT64 = 3,
    TYPE_UINT64 = 4,
    TYPE_INT32 = 5,
    TYPE_FIXED64 = 6,
    TYPE_FIXED32 = 7,
    TYPE_BOOL = 8,
    TYPE_STRING = 9,
    TYPE_GROUP = 10,
    TYPE_MESSAGE = 11,
    TYPE_BYTES = 12,
    TYPE_UINT32 = 13,
    TYPE_ENUM = 14,
    TYPE_SFIXED32 = 15,
    TYPE_SFIXED64 = 16,
    TYPE_SINT32 = 17,
    TYPE_SINT64 = 18,
}

impl FieldDescriptorProto_Type {
    pub fn new(value: i32) -> FieldDescriptorProto_Type {
        match value {
            1 => FieldDescriptorProto_Type::TYPE_DOUBLE,
            2 => FieldDescriptorProto_Type::TYPE_FLOAT,
            3 => FieldDescriptorProto_Type::TYPE_INT64,
            4 => FieldDescriptorProto_Type::TYPE_UINT64,
            5 => FieldDescriptorProto_Type::TYPE_INT32,
            6 => FieldDescriptorProto_Type::TYPE_FIXED64,
            7 => FieldDescriptorProto_Type::TYPE_FIXED32,
            8 => FieldDescriptorProto_Type::TYPE_BOOL,
            9 => FieldDescriptorProto_Type::TYPE_STRING,
            10 => FieldDescriptorProto_Type::TYPE_GROUP,
            11 => FieldDescriptorProto_Type::TYPE_MESSAGE,
            12 => FieldDescriptorProto_Type::TYPE_BYTES,
            13 => FieldDescriptorProto_Type::TYPE_UINT32,
            14 => FieldDescriptorProto_Type::TYPE_ENUM,
            15 => FieldDescriptorProto_Type::TYPE_SFIXED32,
            16 => FieldDescriptorProto_Type::TYPE_SFIXED64,
            17 => FieldDescriptorProto_Type::TYPE_SINT32,
            18 => FieldDescriptorProto_Type::TYPE_SINT64,
            _ => panic!()
        }
    }
}

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

    fn enum_descriptor_static(_: Option<FieldDescriptorProto_Type>) -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("FieldDescriptorProto_Type", file_descriptor_proto())
            })
        }
    }
}

#[deriving(Clone,PartialEq,Eq,Show)]
pub enum FieldDescriptorProto_Label {
    LABEL_OPTIONAL = 1,
    LABEL_REQUIRED = 2,
    LABEL_REPEATED = 3,
}

impl FieldDescriptorProto_Label {
    pub fn new(value: i32) -> FieldDescriptorProto_Label {
        match value {
            1 => FieldDescriptorProto_Label::LABEL_OPTIONAL,
            2 => FieldDescriptorProto_Label::LABEL_REQUIRED,
            3 => FieldDescriptorProto_Label::LABEL_REPEATED,
            _ => panic!()
        }
    }
}

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

    fn enum_descriptor_static(_: Option<FieldDescriptorProto_Label>) -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("FieldDescriptorProto_Label", file_descriptor_proto())
            })
        }
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct EnumDescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    value: ::protobuf::RepeatedField<EnumValueDescriptorProto>,
    options: ::protobuf::SingularPtrField<EnumOptions>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> EnumDescriptorProto {
    pub fn new() -> EnumDescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static EnumDescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<EnumDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const EnumDescriptorProto };
        unsafe {
            instance.get(|| {
                EnumDescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    value: ::protobuf::RepeatedField::new(),
                    options: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;

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

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

    // Mutable pointer to the field.
    pub fn mut_value(&'a mut self) -> &'a mut ::protobuf::RepeatedField<EnumValueDescriptorProto> {
        &mut self.value
    }

    pub fn get_value(&'a self) -> &'a [EnumValueDescriptorProto] {
        self.value.as_slice()
    }

    // optional .google.protobuf.EnumOptions options = 3;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a EnumOptions {
        self.options.as_ref().unwrap_or_else(|| EnumOptions::default_instance())
    }
}

impl ::protobuf::Message for EnumDescriptorProto {
    fn new() -> EnumDescriptorProto {
        EnumDescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.value.push_default();
                    try!(is.merge_message(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.value.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        for v in self.value.iter() {
            try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<EnumDescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<EnumDescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&EnumDescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<EnumDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&EnumDescriptorProto_value_acc as &'static ::protobuf::reflect::FieldAccessor<EnumDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&EnumDescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<EnumDescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<EnumDescriptorProto>(
                    "EnumDescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<EnumDescriptorProto>()
    }
}

impl ::protobuf::Clear for EnumDescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_value();
        self.clear_options();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for EnumDescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct EnumDescriptorProto_name_acc_type;
static EnumDescriptorProto_name_acc: EnumDescriptorProto_name_acc_type = EnumDescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumDescriptorProto> for EnumDescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &EnumDescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a EnumDescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct EnumDescriptorProto_value_acc_type;
static EnumDescriptorProto_value_acc: EnumDescriptorProto_value_acc_type = EnumDescriptorProto_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumDescriptorProto> for EnumDescriptorProto_value_acc_type {
    fn name(&self) -> &'static str {
        "value"
    }

    fn len_field(&self, m: &EnumDescriptorProto) -> uint {
        m.get_value().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a EnumDescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_value()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct EnumDescriptorProto_options_acc_type;
static EnumDescriptorProto_options_acc: EnumDescriptorProto_options_acc_type = EnumDescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumDescriptorProto> for EnumDescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &EnumDescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a EnumDescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct EnumValueDescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    number: ::std::option::Option<i32>,
    options: ::protobuf::SingularPtrField<EnumValueOptions>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> EnumValueDescriptorProto {
    pub fn new() -> EnumValueDescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static EnumValueDescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<EnumValueDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const EnumValueDescriptorProto };
        unsafe {
            instance.get(|| {
                EnumValueDescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    number: ::std::option::None,
                    options: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // optional int32 number = 2;

    pub fn clear_number(&mut self) {
        self.number = None;
    }

    pub fn has_number(&self) -> bool {
        self.number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number(&mut self, v: i32) {
        self.number = Some(v);
    }

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

    // optional .google.protobuf.EnumValueOptions options = 3;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a EnumValueOptions {
        self.options.as_ref().unwrap_or_else(|| EnumValueOptions::default_instance())
    }
}

impl ::protobuf::Message for EnumValueDescriptorProto {
    fn new() -> EnumValueDescriptorProto {
        EnumValueDescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_int32());
                    self.number = Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.number.iter() {
            my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        match self.number {
            Some(v) => {
                try!(os.write_int32(2, v));
            },
            None => {},
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<EnumValueDescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&EnumValueDescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&EnumValueDescriptorProto_number_acc as &'static ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&EnumValueDescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<EnumValueDescriptorProto>(
                    "EnumValueDescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<EnumValueDescriptorProto>()
    }
}

impl ::protobuf::Clear for EnumValueDescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_number();
        self.clear_options();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for EnumValueDescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct EnumValueDescriptorProto_name_acc_type;
static EnumValueDescriptorProto_name_acc: EnumValueDescriptorProto_name_acc_type = EnumValueDescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto> for EnumValueDescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &EnumValueDescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a EnumValueDescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct EnumValueDescriptorProto_number_acc_type;
static EnumValueDescriptorProto_number_acc: EnumValueDescriptorProto_number_acc_type = EnumValueDescriptorProto_number_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto> for EnumValueDescriptorProto_number_acc_type {
    fn name(&self) -> &'static str {
        "number"
    }

    fn has_field(&self, m: &EnumValueDescriptorProto) -> bool {
        m.has_number()
    }

    fn get_i32(&self, m: &EnumValueDescriptorProto) -> i32 {
        m.get_number()
    }
}

#[allow(non_camel_case_types)]
struct EnumValueDescriptorProto_options_acc_type;
static EnumValueDescriptorProto_options_acc: EnumValueDescriptorProto_options_acc_type = EnumValueDescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumValueDescriptorProto> for EnumValueDescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &EnumValueDescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a EnumValueDescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct ServiceDescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    method: ::protobuf::RepeatedField<MethodDescriptorProto>,
    options: ::protobuf::SingularPtrField<ServiceOptions>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> ServiceDescriptorProto {
    pub fn new() -> ServiceDescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static ServiceDescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<ServiceDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ServiceDescriptorProto };
        unsafe {
            instance.get(|| {
                ServiceDescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    method: ::protobuf::RepeatedField::new(),
                    options: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // repeated .google.protobuf.MethodDescriptorProto method = 2;

    pub fn clear_method(&mut self) {
        self.method.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_method(&'a mut self) -> &'a mut ::protobuf::RepeatedField<MethodDescriptorProto> {
        &mut self.method
    }

    pub fn get_method(&'a self) -> &'a [MethodDescriptorProto] {
        self.method.as_slice()
    }

    // optional .google.protobuf.ServiceOptions options = 3;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a ServiceOptions {
        self.options.as_ref().unwrap_or_else(|| ServiceOptions::default_instance())
    }
}

impl ::protobuf::Message for ServiceDescriptorProto {
    fn new() -> ServiceDescriptorProto {
        ServiceDescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.method.push_default();
                    try!(is.merge_message(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.method.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        for v in self.method.iter() {
            try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<ServiceDescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&ServiceDescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&ServiceDescriptorProto_method_acc as &'static ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&ServiceDescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<ServiceDescriptorProto>(
                    "ServiceDescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<ServiceDescriptorProto>()
    }
}

impl ::protobuf::Clear for ServiceDescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_method();
        self.clear_options();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for ServiceDescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct ServiceDescriptorProto_name_acc_type;
static ServiceDescriptorProto_name_acc: ServiceDescriptorProto_name_acc_type = ServiceDescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto> for ServiceDescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &ServiceDescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a ServiceDescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct ServiceDescriptorProto_method_acc_type;
static ServiceDescriptorProto_method_acc: ServiceDescriptorProto_method_acc_type = ServiceDescriptorProto_method_acc_type;

impl ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto> for ServiceDescriptorProto_method_acc_type {
    fn name(&self) -> &'static str {
        "method"
    }

    fn len_field(&self, m: &ServiceDescriptorProto) -> uint {
        m.get_method().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a ServiceDescriptorProto, index: uint) -> &'a ::protobuf::Message {
        &m.get_method()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct ServiceDescriptorProto_options_acc_type;
static ServiceDescriptorProto_options_acc: ServiceDescriptorProto_options_acc_type = ServiceDescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<ServiceDescriptorProto> for ServiceDescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &ServiceDescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a ServiceDescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct MethodDescriptorProto {
    name: ::protobuf::SingularField<::std::string::String>,
    input_type: ::protobuf::SingularField<::std::string::String>,
    output_type: ::protobuf::SingularField<::std::string::String>,
    options: ::protobuf::SingularPtrField<MethodOptions>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> MethodDescriptorProto {
    pub fn new() -> MethodDescriptorProto {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static MethodDescriptorProto {
        static mut instance: ::protobuf::lazy::Lazy<MethodDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const MethodDescriptorProto };
        unsafe {
            instance.get(|| {
                MethodDescriptorProto {
                    name: ::protobuf::SingularField::none(),
                    input_type: ::protobuf::SingularField::none(),
                    output_type: ::protobuf::SingularField::none(),
                    options: ::protobuf::SingularPtrField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string name = 1;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

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

    // optional string input_type = 2;

    pub fn clear_input_type(&mut self) {
        self.input_type.clear();
    }

    pub fn has_input_type(&self) -> bool {
        self.input_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_input_type(&mut self, v: ::std::string::String) {
        self.input_type = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_input_type(&'a mut self) -> &'a mut ::std::string::String {
        if self.input_type.is_none() {
            self.input_type.set_default();
        };
        self.input_type.as_mut().unwrap()
    }

    pub fn get_input_type(&'a self) -> &'a str {
        match self.input_type.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional string output_type = 3;

    pub fn clear_output_type(&mut self) {
        self.output_type.clear();
    }

    pub fn has_output_type(&self) -> bool {
        self.output_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_output_type(&mut self, v: ::std::string::String) {
        self.output_type = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_output_type(&'a mut self) -> &'a mut ::std::string::String {
        if self.output_type.is_none() {
            self.output_type.set_default();
        };
        self.output_type.as_mut().unwrap()
    }

    pub fn get_output_type(&'a self) -> &'a str {
        match self.output_type.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional .google.protobuf.MethodOptions options = 4;

    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

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

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

    pub fn get_options(&'a self) -> &'a MethodOptions {
        self.options.as_ref().unwrap_or_else(|| MethodOptions::default_instance())
    }
}

impl ::protobuf::Message for MethodDescriptorProto {
    fn new() -> MethodDescriptorProto {
        MethodDescriptorProto::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.input_type.set_default();
                    try!(is.read_string_into(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.output_type.set_default();
                    try!(is.read_string_into(tmp))
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.options.set_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.input_type.iter() {
            my_size += ::protobuf::rt::string_size(2, value.as_slice());
        };
        for value in self.output_type.iter() {
            my_size += ::protobuf::rt::string_size(3, value.as_slice());
        };
        for value in self.options.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        match self.input_type.as_ref() {
            Some(v) => {
                try!(os.write_string(2, v.as_slice()));
            },
            None => {},
        };
        match self.output_type.as_ref() {
            Some(v) => {
                try!(os.write_string(3, v.as_slice()));
            },
            None => {},
        };
        match self.options.as_ref() {
            Some(v) => {
                try!(os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited));
                try!(os.write_raw_varint32(sizes[*sizes_pos]));
                *sizes_pos += 1;
                try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<MethodDescriptorProto>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<MethodDescriptorProto>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&MethodDescriptorProto_name_acc as &'static ::protobuf::reflect::FieldAccessor<MethodDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&MethodDescriptorProto_input_type_acc as &'static ::protobuf::reflect::FieldAccessor<MethodDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&MethodDescriptorProto_output_type_acc as &'static ::protobuf::reflect::FieldAccessor<MethodDescriptorProto>) });
                fields.push(unsafe { ::std::mem::transmute(&MethodDescriptorProto_options_acc as &'static ::protobuf::reflect::FieldAccessor<MethodDescriptorProto>) });
                ::protobuf::reflect::MessageDescriptor::new::<MethodDescriptorProto>(
                    "MethodDescriptorProto",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<MethodDescriptorProto>()
    }
}

impl ::protobuf::Clear for MethodDescriptorProto {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_input_type();
        self.clear_output_type();
        self.clear_options();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for MethodDescriptorProto {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct MethodDescriptorProto_name_acc_type;
static MethodDescriptorProto_name_acc: MethodDescriptorProto_name_acc_type = MethodDescriptorProto_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<MethodDescriptorProto> for MethodDescriptorProto_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn has_field(&self, m: &MethodDescriptorProto) -> bool {
        m.has_name()
    }

    fn get_str<'a>(&self, m: &'a MethodDescriptorProto) -> &'a str {
        m.get_name()
    }
}

#[allow(non_camel_case_types)]
struct MethodDescriptorProto_input_type_acc_type;
static MethodDescriptorProto_input_type_acc: MethodDescriptorProto_input_type_acc_type = MethodDescriptorProto_input_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<MethodDescriptorProto> for MethodDescriptorProto_input_type_acc_type {
    fn name(&self) -> &'static str {
        "input_type"
    }

    fn has_field(&self, m: &MethodDescriptorProto) -> bool {
        m.has_input_type()
    }

    fn get_str<'a>(&self, m: &'a MethodDescriptorProto) -> &'a str {
        m.get_input_type()
    }
}

#[allow(non_camel_case_types)]
struct MethodDescriptorProto_output_type_acc_type;
static MethodDescriptorProto_output_type_acc: MethodDescriptorProto_output_type_acc_type = MethodDescriptorProto_output_type_acc_type;

impl ::protobuf::reflect::FieldAccessor<MethodDescriptorProto> for MethodDescriptorProto_output_type_acc_type {
    fn name(&self) -> &'static str {
        "output_type"
    }

    fn has_field(&self, m: &MethodDescriptorProto) -> bool {
        m.has_output_type()
    }

    fn get_str<'a>(&self, m: &'a MethodDescriptorProto) -> &'a str {
        m.get_output_type()
    }
}

#[allow(non_camel_case_types)]
struct MethodDescriptorProto_options_acc_type;
static MethodDescriptorProto_options_acc: MethodDescriptorProto_options_acc_type = MethodDescriptorProto_options_acc_type;

impl ::protobuf::reflect::FieldAccessor<MethodDescriptorProto> for MethodDescriptorProto_options_acc_type {
    fn name(&self) -> &'static str {
        "options"
    }

    fn has_field(&self, m: &MethodDescriptorProto) -> bool {
        m.has_options()
    }

    fn get_message<'a>(&self, m: &'a MethodDescriptorProto) -> &'a ::protobuf::Message {
        m.get_options() as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct FileOptions {
    java_package: ::protobuf::SingularField<::std::string::String>,
    java_outer_classname: ::protobuf::SingularField<::std::string::String>,
    java_multiple_files: ::std::option::Option<bool>,
    java_generate_equals_and_hash: ::std::option::Option<bool>,
    optimize_for: ::std::option::Option<FileOptions_OptimizeMode>,
    go_package: ::protobuf::SingularField<::std::string::String>,
    cc_generic_services: ::std::option::Option<bool>,
    java_generic_services: ::std::option::Option<bool>,
    py_generic_services: ::std::option::Option<bool>,
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> FileOptions {
    pub fn new() -> FileOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static FileOptions {
        static mut instance: ::protobuf::lazy::Lazy<FileOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FileOptions };
        unsafe {
            instance.get(|| {
                FileOptions {
                    java_package: ::protobuf::SingularField::none(),
                    java_outer_classname: ::protobuf::SingularField::none(),
                    java_multiple_files: ::std::option::None,
                    java_generate_equals_and_hash: ::std::option::None,
                    optimize_for: ::std::option::None,
                    go_package: ::protobuf::SingularField::none(),
                    cc_generic_services: ::std::option::None,
                    java_generic_services: ::std::option::None,
                    py_generic_services: ::std::option::None,
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional string java_package = 1;

    pub fn clear_java_package(&mut self) {
        self.java_package.clear();
    }

    pub fn has_java_package(&self) -> bool {
        self.java_package.is_some()
    }

    // Param is passed by value, moved
    pub fn set_java_package(&mut self, v: ::std::string::String) {
        self.java_package = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_java_package(&'a mut self) -> &'a mut ::std::string::String {
        if self.java_package.is_none() {
            self.java_package.set_default();
        };
        self.java_package.as_mut().unwrap()
    }

    pub fn get_java_package(&'a self) -> &'a str {
        match self.java_package.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional string java_outer_classname = 8;

    pub fn clear_java_outer_classname(&mut self) {
        self.java_outer_classname.clear();
    }

    pub fn has_java_outer_classname(&self) -> bool {
        self.java_outer_classname.is_some()
    }

    // Param is passed by value, moved
    pub fn set_java_outer_classname(&mut self, v: ::std::string::String) {
        self.java_outer_classname = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_java_outer_classname(&'a mut self) -> &'a mut ::std::string::String {
        if self.java_outer_classname.is_none() {
            self.java_outer_classname.set_default();
        };
        self.java_outer_classname.as_mut().unwrap()
    }

    pub fn get_java_outer_classname(&'a self) -> &'a str {
        match self.java_outer_classname.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional bool java_multiple_files = 10;

    pub fn clear_java_multiple_files(&mut self) {
        self.java_multiple_files = None;
    }

    pub fn has_java_multiple_files(&self) -> bool {
        self.java_multiple_files.is_some()
    }

    // Param is passed by value, moved
    pub fn set_java_multiple_files(&mut self, v: bool) {
        self.java_multiple_files = Some(v);
    }

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

    // optional bool java_generate_equals_and_hash = 20;

    pub fn clear_java_generate_equals_and_hash(&mut self) {
        self.java_generate_equals_and_hash = None;
    }

    pub fn has_java_generate_equals_and_hash(&self) -> bool {
        self.java_generate_equals_and_hash.is_some()
    }

    // Param is passed by value, moved
    pub fn set_java_generate_equals_and_hash(&mut self, v: bool) {
        self.java_generate_equals_and_hash = Some(v);
    }

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

    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9;

    pub fn clear_optimize_for(&mut self) {
        self.optimize_for = None;
    }

    pub fn has_optimize_for(&self) -> bool {
        self.optimize_for.is_some()
    }

    // Param is passed by value, moved
    pub fn set_optimize_for(&mut self, v: FileOptions_OptimizeMode) {
        self.optimize_for = Some(v);
    }

    pub fn get_optimize_for(&self) -> FileOptions_OptimizeMode {
        self.optimize_for.unwrap_or(FileOptions_OptimizeMode::SPEED)
    }

    // optional string go_package = 11;

    pub fn clear_go_package(&mut self) {
        self.go_package.clear();
    }

    pub fn has_go_package(&self) -> bool {
        self.go_package.is_some()
    }

    // Param is passed by value, moved
    pub fn set_go_package(&mut self, v: ::std::string::String) {
        self.go_package = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_go_package(&'a mut self) -> &'a mut ::std::string::String {
        if self.go_package.is_none() {
            self.go_package.set_default();
        };
        self.go_package.as_mut().unwrap()
    }

    pub fn get_go_package(&'a self) -> &'a str {
        match self.go_package.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional bool cc_generic_services = 16;

    pub fn clear_cc_generic_services(&mut self) {
        self.cc_generic_services = None;
    }

    pub fn has_cc_generic_services(&self) -> bool {
        self.cc_generic_services.is_some()
    }

    // Param is passed by value, moved
    pub fn set_cc_generic_services(&mut self, v: bool) {
        self.cc_generic_services = Some(v);
    }

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

    // optional bool java_generic_services = 17;

    pub fn clear_java_generic_services(&mut self) {
        self.java_generic_services = None;
    }

    pub fn has_java_generic_services(&self) -> bool {
        self.java_generic_services.is_some()
    }

    // Param is passed by value, moved
    pub fn set_java_generic_services(&mut self, v: bool) {
        self.java_generic_services = Some(v);
    }

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

    // optional bool py_generic_services = 18;

    pub fn clear_py_generic_services(&mut self) {
        self.py_generic_services = None;
    }

    pub fn has_py_generic_services(&self) -> bool {
        self.py_generic_services.is_some()
    }

    // Param is passed by value, moved
    pub fn set_py_generic_services(&mut self, v: bool) {
        self.py_generic_services = Some(v);
    }

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

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for FileOptions {
    fn new() -> FileOptions {
        FileOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.java_package.set_default();
                    try!(is.read_string_into(tmp))
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.java_outer_classname.set_default();
                    try!(is.read_string_into(tmp))
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.java_multiple_files = Some(tmp);
                },
                20 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.java_generate_equals_and_hash = Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = FileOptions_OptimizeMode::new(try!(is.read_int32()));
                    self.optimize_for = Some(tmp);
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.go_package.set_default();
                    try!(is.read_string_into(tmp))
                },
                16 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.cc_generic_services = Some(tmp);
                },
                17 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.java_generic_services = Some(tmp);
                },
                18 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.py_generic_services = Some(tmp);
                },
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.java_package.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        for value in self.java_outer_classname.iter() {
            my_size += ::protobuf::rt::string_size(8, value.as_slice());
        };
        if self.java_multiple_files.is_some() {
            my_size += 2;
        };
        if self.java_generate_equals_and_hash.is_some() {
            my_size += 3;
        };
        for value in self.optimize_for.iter() {
            my_size += ::protobuf::rt::enum_size(9, *value);
        };
        for value in self.go_package.iter() {
            my_size += ::protobuf::rt::string_size(11, value.as_slice());
        };
        if self.cc_generic_services.is_some() {
            my_size += 3;
        };
        if self.java_generic_services.is_some() {
            my_size += 3;
        };
        if self.py_generic_services.is_some() {
            my_size += 3;
        };
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.java_package.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        match self.java_outer_classname.as_ref() {
            Some(v) => {
                try!(os.write_string(8, v.as_slice()));
            },
            None => {},
        };
        match self.java_multiple_files {
            Some(v) => {
                try!(os.write_bool(10, v));
            },
            None => {},
        };
        match self.java_generate_equals_and_hash {
            Some(v) => {
                try!(os.write_bool(20, v));
            },
            None => {},
        };
        match self.optimize_for {
            Some(v) => {
                try!(os.write_enum(9, v as i32));
            },
            None => {},
        };
        match self.go_package.as_ref() {
            Some(v) => {
                try!(os.write_string(11, v.as_slice()));
            },
            None => {},
        };
        match self.cc_generic_services {
            Some(v) => {
                try!(os.write_bool(16, v));
            },
            None => {},
        };
        match self.java_generic_services {
            Some(v) => {
                try!(os.write_bool(17, v));
            },
            None => {},
        };
        match self.py_generic_services {
            Some(v) => {
                try!(os.write_bool(18, v));
            },
            None => {},
        };
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<FileOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<FileOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_java_package_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_java_outer_classname_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_java_multiple_files_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_java_generate_equals_and_hash_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_optimize_for_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_go_package_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_cc_generic_services_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_java_generic_services_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_py_generic_services_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FileOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<FileOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<FileOptions>(
                    "FileOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<FileOptions>()
    }
}

impl ::protobuf::Clear for FileOptions {
    fn clear(&mut self) {
        self.clear_java_package();
        self.clear_java_outer_classname();
        self.clear_java_multiple_files();
        self.clear_java_generate_equals_and_hash();
        self.clear_optimize_for();
        self.clear_go_package();
        self.clear_cc_generic_services();
        self.clear_java_generic_services();
        self.clear_py_generic_services();
        self.clear_uninterpreted_option();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for FileOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct FileOptions_java_package_acc_type;
static FileOptions_java_package_acc: FileOptions_java_package_acc_type = FileOptions_java_package_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_java_package_acc_type {
    fn name(&self) -> &'static str {
        "java_package"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_java_package()
    }

    fn get_str<'a>(&self, m: &'a FileOptions) -> &'a str {
        m.get_java_package()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_java_outer_classname_acc_type;
static FileOptions_java_outer_classname_acc: FileOptions_java_outer_classname_acc_type = FileOptions_java_outer_classname_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_java_outer_classname_acc_type {
    fn name(&self) -> &'static str {
        "java_outer_classname"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_java_outer_classname()
    }

    fn get_str<'a>(&self, m: &'a FileOptions) -> &'a str {
        m.get_java_outer_classname()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_java_multiple_files_acc_type;
static FileOptions_java_multiple_files_acc: FileOptions_java_multiple_files_acc_type = FileOptions_java_multiple_files_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_java_multiple_files_acc_type {
    fn name(&self) -> &'static str {
        "java_multiple_files"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_java_multiple_files()
    }

    fn get_bool(&self, m: &FileOptions) -> bool {
        m.get_java_multiple_files()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_java_generate_equals_and_hash_acc_type;
static FileOptions_java_generate_equals_and_hash_acc: FileOptions_java_generate_equals_and_hash_acc_type = FileOptions_java_generate_equals_and_hash_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_java_generate_equals_and_hash_acc_type {
    fn name(&self) -> &'static str {
        "java_generate_equals_and_hash"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_java_generate_equals_and_hash()
    }

    fn get_bool(&self, m: &FileOptions) -> bool {
        m.get_java_generate_equals_and_hash()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_optimize_for_acc_type;
static FileOptions_optimize_for_acc: FileOptions_optimize_for_acc_type = FileOptions_optimize_for_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_optimize_for_acc_type {
    fn name(&self) -> &'static str {
        "optimize_for"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_optimize_for()
    }

    fn get_enum<'a>(&self, m: &FileOptions) -> &'static ::protobuf::reflect::EnumValueDescriptor {
        use protobuf::{ProtobufEnum};
        m.get_optimize_for().descriptor()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_go_package_acc_type;
static FileOptions_go_package_acc: FileOptions_go_package_acc_type = FileOptions_go_package_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_go_package_acc_type {
    fn name(&self) -> &'static str {
        "go_package"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_go_package()
    }

    fn get_str<'a>(&self, m: &'a FileOptions) -> &'a str {
        m.get_go_package()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_cc_generic_services_acc_type;
static FileOptions_cc_generic_services_acc: FileOptions_cc_generic_services_acc_type = FileOptions_cc_generic_services_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_cc_generic_services_acc_type {
    fn name(&self) -> &'static str {
        "cc_generic_services"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_cc_generic_services()
    }

    fn get_bool(&self, m: &FileOptions) -> bool {
        m.get_cc_generic_services()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_java_generic_services_acc_type;
static FileOptions_java_generic_services_acc: FileOptions_java_generic_services_acc_type = FileOptions_java_generic_services_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_java_generic_services_acc_type {
    fn name(&self) -> &'static str {
        "java_generic_services"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_java_generic_services()
    }

    fn get_bool(&self, m: &FileOptions) -> bool {
        m.get_java_generic_services()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_py_generic_services_acc_type;
static FileOptions_py_generic_services_acc: FileOptions_py_generic_services_acc_type = FileOptions_py_generic_services_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_py_generic_services_acc_type {
    fn name(&self) -> &'static str {
        "py_generic_services"
    }

    fn has_field(&self, m: &FileOptions) -> bool {
        m.has_py_generic_services()
    }

    fn get_bool(&self, m: &FileOptions) -> bool {
        m.get_py_generic_services()
    }
}

#[allow(non_camel_case_types)]
struct FileOptions_uninterpreted_option_acc_type;
static FileOptions_uninterpreted_option_acc: FileOptions_uninterpreted_option_acc_type = FileOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<FileOptions> for FileOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &FileOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FileOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Eq,Show)]
pub enum FileOptions_OptimizeMode {
    SPEED = 1,
    CODE_SIZE = 2,
    LITE_RUNTIME = 3,
}

impl FileOptions_OptimizeMode {
    pub fn new(value: i32) -> FileOptions_OptimizeMode {
        match value {
            1 => FileOptions_OptimizeMode::SPEED,
            2 => FileOptions_OptimizeMode::CODE_SIZE,
            3 => FileOptions_OptimizeMode::LITE_RUNTIME,
            _ => panic!()
        }
    }
}

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

    fn enum_descriptor_static(_: Option<FileOptions_OptimizeMode>) -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("FileOptions_OptimizeMode", file_descriptor_proto())
            })
        }
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct MessageOptions {
    message_set_wire_format: ::std::option::Option<bool>,
    no_standard_descriptor_accessor: ::std::option::Option<bool>,
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> MessageOptions {
    pub fn new() -> MessageOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static MessageOptions {
        static mut instance: ::protobuf::lazy::Lazy<MessageOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const MessageOptions };
        unsafe {
            instance.get(|| {
                MessageOptions {
                    message_set_wire_format: ::std::option::None,
                    no_standard_descriptor_accessor: ::std::option::None,
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional bool message_set_wire_format = 1;

    pub fn clear_message_set_wire_format(&mut self) {
        self.message_set_wire_format = None;
    }

    pub fn has_message_set_wire_format(&self) -> bool {
        self.message_set_wire_format.is_some()
    }

    // Param is passed by value, moved
    pub fn set_message_set_wire_format(&mut self, v: bool) {
        self.message_set_wire_format = Some(v);
    }

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

    // optional bool no_standard_descriptor_accessor = 2;

    pub fn clear_no_standard_descriptor_accessor(&mut self) {
        self.no_standard_descriptor_accessor = None;
    }

    pub fn has_no_standard_descriptor_accessor(&self) -> bool {
        self.no_standard_descriptor_accessor.is_some()
    }

    // Param is passed by value, moved
    pub fn set_no_standard_descriptor_accessor(&mut self, v: bool) {
        self.no_standard_descriptor_accessor = Some(v);
    }

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

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for MessageOptions {
    fn new() -> MessageOptions {
        MessageOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.message_set_wire_format = Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.no_standard_descriptor_accessor = Some(tmp);
                },
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        if self.message_set_wire_format.is_some() {
            my_size += 2;
        };
        if self.no_standard_descriptor_accessor.is_some() {
            my_size += 2;
        };
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.message_set_wire_format {
            Some(v) => {
                try!(os.write_bool(1, v));
            },
            None => {},
        };
        match self.no_standard_descriptor_accessor {
            Some(v) => {
                try!(os.write_bool(2, v));
            },
            None => {},
        };
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<MessageOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<MessageOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&MessageOptions_message_set_wire_format_acc as &'static ::protobuf::reflect::FieldAccessor<MessageOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&MessageOptions_no_standard_descriptor_accessor_acc as &'static ::protobuf::reflect::FieldAccessor<MessageOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&MessageOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<MessageOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<MessageOptions>(
                    "MessageOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<MessageOptions>()
    }
}

impl ::protobuf::Clear for MessageOptions {
    fn clear(&mut self) {
        self.clear_message_set_wire_format();
        self.clear_no_standard_descriptor_accessor();
        self.clear_uninterpreted_option();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for MessageOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct MessageOptions_message_set_wire_format_acc_type;
static MessageOptions_message_set_wire_format_acc: MessageOptions_message_set_wire_format_acc_type = MessageOptions_message_set_wire_format_acc_type;

impl ::protobuf::reflect::FieldAccessor<MessageOptions> for MessageOptions_message_set_wire_format_acc_type {
    fn name(&self) -> &'static str {
        "message_set_wire_format"
    }

    fn has_field(&self, m: &MessageOptions) -> bool {
        m.has_message_set_wire_format()
    }

    fn get_bool(&self, m: &MessageOptions) -> bool {
        m.get_message_set_wire_format()
    }
}

#[allow(non_camel_case_types)]
struct MessageOptions_no_standard_descriptor_accessor_acc_type;
static MessageOptions_no_standard_descriptor_accessor_acc: MessageOptions_no_standard_descriptor_accessor_acc_type = MessageOptions_no_standard_descriptor_accessor_acc_type;

impl ::protobuf::reflect::FieldAccessor<MessageOptions> for MessageOptions_no_standard_descriptor_accessor_acc_type {
    fn name(&self) -> &'static str {
        "no_standard_descriptor_accessor"
    }

    fn has_field(&self, m: &MessageOptions) -> bool {
        m.has_no_standard_descriptor_accessor()
    }

    fn get_bool(&self, m: &MessageOptions) -> bool {
        m.get_no_standard_descriptor_accessor()
    }
}

#[allow(non_camel_case_types)]
struct MessageOptions_uninterpreted_option_acc_type;
static MessageOptions_uninterpreted_option_acc: MessageOptions_uninterpreted_option_acc_type = MessageOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<MessageOptions> for MessageOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &MessageOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a MessageOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct FieldOptions {
    ctype: ::std::option::Option<FieldOptions_CType>,
    packed: ::std::option::Option<bool>,
    lazy: ::std::option::Option<bool>,
    deprecated: ::std::option::Option<bool>,
    experimental_map_key: ::protobuf::SingularField<::std::string::String>,
    weak: ::std::option::Option<bool>,
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> FieldOptions {
    pub fn new() -> FieldOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static FieldOptions {
        static mut instance: ::protobuf::lazy::Lazy<FieldOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FieldOptions };
        unsafe {
            instance.get(|| {
                FieldOptions {
                    ctype: ::std::option::None,
                    packed: ::std::option::None,
                    lazy: ::std::option::None,
                    deprecated: ::std::option::None,
                    experimental_map_key: ::protobuf::SingularField::none(),
                    weak: ::std::option::None,
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional .google.protobuf.FieldOptions.CType ctype = 1;

    pub fn clear_ctype(&mut self) {
        self.ctype = None;
    }

    pub fn has_ctype(&self) -> bool {
        self.ctype.is_some()
    }

    // Param is passed by value, moved
    pub fn set_ctype(&mut self, v: FieldOptions_CType) {
        self.ctype = Some(v);
    }

    pub fn get_ctype(&self) -> FieldOptions_CType {
        self.ctype.unwrap_or(FieldOptions_CType::STRING)
    }

    // optional bool packed = 2;

    pub fn clear_packed(&mut self) {
        self.packed = None;
    }

    pub fn has_packed(&self) -> bool {
        self.packed.is_some()
    }

    // Param is passed by value, moved
    pub fn set_packed(&mut self, v: bool) {
        self.packed = Some(v);
    }

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

    // optional bool lazy = 5;

    pub fn clear_lazy(&mut self) {
        self.lazy = None;
    }

    pub fn has_lazy(&self) -> bool {
        self.lazy.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lazy(&mut self, v: bool) {
        self.lazy = Some(v);
    }

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

    // optional bool deprecated = 3;

    pub fn clear_deprecated(&mut self) {
        self.deprecated = None;
    }

    pub fn has_deprecated(&self) -> bool {
        self.deprecated.is_some()
    }

    // Param is passed by value, moved
    pub fn set_deprecated(&mut self, v: bool) {
        self.deprecated = Some(v);
    }

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

    // optional string experimental_map_key = 9;

    pub fn clear_experimental_map_key(&mut self) {
        self.experimental_map_key.clear();
    }

    pub fn has_experimental_map_key(&self) -> bool {
        self.experimental_map_key.is_some()
    }

    // Param is passed by value, moved
    pub fn set_experimental_map_key(&mut self, v: ::std::string::String) {
        self.experimental_map_key = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_experimental_map_key(&'a mut self) -> &'a mut ::std::string::String {
        if self.experimental_map_key.is_none() {
            self.experimental_map_key.set_default();
        };
        self.experimental_map_key.as_mut().unwrap()
    }

    pub fn get_experimental_map_key(&'a self) -> &'a str {
        match self.experimental_map_key.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional bool weak = 10;

    pub fn clear_weak(&mut self) {
        self.weak = None;
    }

    pub fn has_weak(&self) -> bool {
        self.weak.is_some()
    }

    // Param is passed by value, moved
    pub fn set_weak(&mut self, v: bool) {
        self.weak = Some(v);
    }

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

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for FieldOptions {
    fn new() -> FieldOptions {
        FieldOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = FieldOptions_CType::new(try!(is.read_int32()));
                    self.ctype = Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.packed = Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.lazy = Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.deprecated = Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.experimental_map_key.set_default();
                    try!(is.read_string_into(tmp))
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.weak = Some(tmp);
                },
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.ctype.iter() {
            my_size += ::protobuf::rt::enum_size(1, *value);
        };
        if self.packed.is_some() {
            my_size += 2;
        };
        if self.lazy.is_some() {
            my_size += 2;
        };
        if self.deprecated.is_some() {
            my_size += 2;
        };
        for value in self.experimental_map_key.iter() {
            my_size += ::protobuf::rt::string_size(9, value.as_slice());
        };
        if self.weak.is_some() {
            my_size += 2;
        };
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.ctype {
            Some(v) => {
                try!(os.write_enum(1, v as i32));
            },
            None => {},
        };
        match self.packed {
            Some(v) => {
                try!(os.write_bool(2, v));
            },
            None => {},
        };
        match self.lazy {
            Some(v) => {
                try!(os.write_bool(5, v));
            },
            None => {},
        };
        match self.deprecated {
            Some(v) => {
                try!(os.write_bool(3, v));
            },
            None => {},
        };
        match self.experimental_map_key.as_ref() {
            Some(v) => {
                try!(os.write_string(9, v.as_slice()));
            },
            None => {},
        };
        match self.weak {
            Some(v) => {
                try!(os.write_bool(10, v));
            },
            None => {},
        };
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<FieldOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<FieldOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_ctype_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_packed_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_lazy_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_deprecated_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_experimental_map_key_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_weak_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&FieldOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<FieldOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<FieldOptions>(
                    "FieldOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<FieldOptions>()
    }
}

impl ::protobuf::Clear for FieldOptions {
    fn clear(&mut self) {
        self.clear_ctype();
        self.clear_packed();
        self.clear_lazy();
        self.clear_deprecated();
        self.clear_experimental_map_key();
        self.clear_weak();
        self.clear_uninterpreted_option();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for FieldOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct FieldOptions_ctype_acc_type;
static FieldOptions_ctype_acc: FieldOptions_ctype_acc_type = FieldOptions_ctype_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_ctype_acc_type {
    fn name(&self) -> &'static str {
        "ctype"
    }

    fn has_field(&self, m: &FieldOptions) -> bool {
        m.has_ctype()
    }

    fn get_enum<'a>(&self, m: &FieldOptions) -> &'static ::protobuf::reflect::EnumValueDescriptor {
        use protobuf::{ProtobufEnum};
        m.get_ctype().descriptor()
    }
}

#[allow(non_camel_case_types)]
struct FieldOptions_packed_acc_type;
static FieldOptions_packed_acc: FieldOptions_packed_acc_type = FieldOptions_packed_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_packed_acc_type {
    fn name(&self) -> &'static str {
        "packed"
    }

    fn has_field(&self, m: &FieldOptions) -> bool {
        m.has_packed()
    }

    fn get_bool(&self, m: &FieldOptions) -> bool {
        m.get_packed()
    }
}

#[allow(non_camel_case_types)]
struct FieldOptions_lazy_acc_type;
static FieldOptions_lazy_acc: FieldOptions_lazy_acc_type = FieldOptions_lazy_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_lazy_acc_type {
    fn name(&self) -> &'static str {
        "lazy"
    }

    fn has_field(&self, m: &FieldOptions) -> bool {
        m.has_lazy()
    }

    fn get_bool(&self, m: &FieldOptions) -> bool {
        m.get_lazy()
    }
}

#[allow(non_camel_case_types)]
struct FieldOptions_deprecated_acc_type;
static FieldOptions_deprecated_acc: FieldOptions_deprecated_acc_type = FieldOptions_deprecated_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_deprecated_acc_type {
    fn name(&self) -> &'static str {
        "deprecated"
    }

    fn has_field(&self, m: &FieldOptions) -> bool {
        m.has_deprecated()
    }

    fn get_bool(&self, m: &FieldOptions) -> bool {
        m.get_deprecated()
    }
}

#[allow(non_camel_case_types)]
struct FieldOptions_experimental_map_key_acc_type;
static FieldOptions_experimental_map_key_acc: FieldOptions_experimental_map_key_acc_type = FieldOptions_experimental_map_key_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_experimental_map_key_acc_type {
    fn name(&self) -> &'static str {
        "experimental_map_key"
    }

    fn has_field(&self, m: &FieldOptions) -> bool {
        m.has_experimental_map_key()
    }

    fn get_str<'a>(&self, m: &'a FieldOptions) -> &'a str {
        m.get_experimental_map_key()
    }
}

#[allow(non_camel_case_types)]
struct FieldOptions_weak_acc_type;
static FieldOptions_weak_acc: FieldOptions_weak_acc_type = FieldOptions_weak_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_weak_acc_type {
    fn name(&self) -> &'static str {
        "weak"
    }

    fn has_field(&self, m: &FieldOptions) -> bool {
        m.has_weak()
    }

    fn get_bool(&self, m: &FieldOptions) -> bool {
        m.get_weak()
    }
}

#[allow(non_camel_case_types)]
struct FieldOptions_uninterpreted_option_acc_type;
static FieldOptions_uninterpreted_option_acc: FieldOptions_uninterpreted_option_acc_type = FieldOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<FieldOptions> for FieldOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &FieldOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a FieldOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Eq,Show)]
pub enum FieldOptions_CType {
    STRING = 0,
    CORD = 1,
    STRING_PIECE = 2,
}

impl FieldOptions_CType {
    pub fn new(value: i32) -> FieldOptions_CType {
        match value {
            0 => FieldOptions_CType::STRING,
            1 => FieldOptions_CType::CORD,
            2 => FieldOptions_CType::STRING_PIECE,
            _ => panic!()
        }
    }
}

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

    fn enum_descriptor_static(_: Option<FieldOptions_CType>) -> &'static ::protobuf::reflect::EnumDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("FieldOptions_CType", file_descriptor_proto())
            })
        }
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct EnumOptions {
    allow_alias: ::std::option::Option<bool>,
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> EnumOptions {
    pub fn new() -> EnumOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static EnumOptions {
        static mut instance: ::protobuf::lazy::Lazy<EnumOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const EnumOptions };
        unsafe {
            instance.get(|| {
                EnumOptions {
                    allow_alias: ::std::option::None,
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // optional bool allow_alias = 2;

    pub fn clear_allow_alias(&mut self) {
        self.allow_alias = None;
    }

    pub fn has_allow_alias(&self) -> bool {
        self.allow_alias.is_some()
    }

    // Param is passed by value, moved
    pub fn set_allow_alias(&mut self, v: bool) {
        self.allow_alias = Some(v);
    }

    pub fn get_allow_alias(&self) -> bool {
        self.allow_alias.unwrap_or(true)
    }

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for EnumOptions {
    fn new() -> EnumOptions {
        EnumOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.allow_alias = Some(tmp);
                },
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        if self.allow_alias.is_some() {
            my_size += 2;
        };
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.allow_alias {
            Some(v) => {
                try!(os.write_bool(2, v));
            },
            None => {},
        };
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<EnumOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<EnumOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&EnumOptions_allow_alias_acc as &'static ::protobuf::reflect::FieldAccessor<EnumOptions>) });
                fields.push(unsafe { ::std::mem::transmute(&EnumOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<EnumOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<EnumOptions>(
                    "EnumOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<EnumOptions>()
    }
}

impl ::protobuf::Clear for EnumOptions {
    fn clear(&mut self) {
        self.clear_allow_alias();
        self.clear_uninterpreted_option();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for EnumOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct EnumOptions_allow_alias_acc_type;
static EnumOptions_allow_alias_acc: EnumOptions_allow_alias_acc_type = EnumOptions_allow_alias_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumOptions> for EnumOptions_allow_alias_acc_type {
    fn name(&self) -> &'static str {
        "allow_alias"
    }

    fn has_field(&self, m: &EnumOptions) -> bool {
        m.has_allow_alias()
    }

    fn get_bool(&self, m: &EnumOptions) -> bool {
        m.get_allow_alias()
    }
}

#[allow(non_camel_case_types)]
struct EnumOptions_uninterpreted_option_acc_type;
static EnumOptions_uninterpreted_option_acc: EnumOptions_uninterpreted_option_acc_type = EnumOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumOptions> for EnumOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &EnumOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a EnumOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct EnumValueOptions {
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> EnumValueOptions {
    pub fn new() -> EnumValueOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static EnumValueOptions {
        static mut instance: ::protobuf::lazy::Lazy<EnumValueOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const EnumValueOptions };
        unsafe {
            instance.get(|| {
                EnumValueOptions {
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for EnumValueOptions {
    fn new() -> EnumValueOptions {
        EnumValueOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<EnumValueOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<EnumValueOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&EnumValueOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<EnumValueOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<EnumValueOptions>(
                    "EnumValueOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<EnumValueOptions>()
    }
}

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

impl ::std::fmt::Show for EnumValueOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct EnumValueOptions_uninterpreted_option_acc_type;
static EnumValueOptions_uninterpreted_option_acc: EnumValueOptions_uninterpreted_option_acc_type = EnumValueOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<EnumValueOptions> for EnumValueOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &EnumValueOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a EnumValueOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct ServiceOptions {
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> ServiceOptions {
    pub fn new() -> ServiceOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static ServiceOptions {
        static mut instance: ::protobuf::lazy::Lazy<ServiceOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ServiceOptions };
        unsafe {
            instance.get(|| {
                ServiceOptions {
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for ServiceOptions {
    fn new() -> ServiceOptions {
        ServiceOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<ServiceOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<ServiceOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&ServiceOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<ServiceOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<ServiceOptions>(
                    "ServiceOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<ServiceOptions>()
    }
}

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

impl ::std::fmt::Show for ServiceOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct ServiceOptions_uninterpreted_option_acc_type;
static ServiceOptions_uninterpreted_option_acc: ServiceOptions_uninterpreted_option_acc_type = ServiceOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<ServiceOptions> for ServiceOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &ServiceOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a ServiceOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct MethodOptions {
    uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> MethodOptions {
    pub fn new() -> MethodOptions {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static MethodOptions {
        static mut instance: ::protobuf::lazy::Lazy<MethodOptions> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const MethodOptions };
        unsafe {
            instance.get(|| {
                MethodOptions {
                    uninterpreted_option: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;

    pub fn clear_uninterpreted_option(&mut self) {
        self.uninterpreted_option.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_uninterpreted_option(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption> {
        &mut self.uninterpreted_option
    }

    pub fn get_uninterpreted_option(&'a self) -> &'a [UninterpretedOption] {
        self.uninterpreted_option.as_slice()
    }
}

impl ::protobuf::Message for MethodOptions {
    fn new() -> MethodOptions {
        MethodOptions::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                999 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.uninterpreted_option.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.uninterpreted_option.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        for v in self.uninterpreted_option.iter() {
            try!(os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<MethodOptions>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<MethodOptions>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&MethodOptions_uninterpreted_option_acc as &'static ::protobuf::reflect::FieldAccessor<MethodOptions>) });
                ::protobuf::reflect::MessageDescriptor::new::<MethodOptions>(
                    "MethodOptions",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<MethodOptions>()
    }
}

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

impl ::std::fmt::Show for MethodOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct MethodOptions_uninterpreted_option_acc_type;
static MethodOptions_uninterpreted_option_acc: MethodOptions_uninterpreted_option_acc_type = MethodOptions_uninterpreted_option_acc_type;

impl ::protobuf::reflect::FieldAccessor<MethodOptions> for MethodOptions_uninterpreted_option_acc_type {
    fn name(&self) -> &'static str {
        "uninterpreted_option"
    }

    fn len_field(&self, m: &MethodOptions) -> uint {
        m.get_uninterpreted_option().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a MethodOptions, index: uint) -> &'a ::protobuf::Message {
        &m.get_uninterpreted_option()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct UninterpretedOption {
    name: ::protobuf::RepeatedField<UninterpretedOption_NamePart>,
    identifier_value: ::protobuf::SingularField<::std::string::String>,
    positive_int_value: ::std::option::Option<u64>,
    negative_int_value: ::std::option::Option<i64>,
    double_value: ::std::option::Option<f64>,
    string_value: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    aggregate_value: ::protobuf::SingularField<::std::string::String>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> UninterpretedOption {
    pub fn new() -> UninterpretedOption {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static UninterpretedOption {
        static mut instance: ::protobuf::lazy::Lazy<UninterpretedOption> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const UninterpretedOption };
        unsafe {
            instance.get(|| {
                UninterpretedOption {
                    name: ::protobuf::RepeatedField::new(),
                    identifier_value: ::protobuf::SingularField::none(),
                    positive_int_value: ::std::option::None,
                    negative_int_value: ::std::option::None,
                    double_value: ::std::option::None,
                    string_value: ::protobuf::SingularField::none(),
                    aggregate_value: ::protobuf::SingularField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;

    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_name(&'a mut self) -> &'a mut ::protobuf::RepeatedField<UninterpretedOption_NamePart> {
        &mut self.name
    }

    pub fn get_name(&'a self) -> &'a [UninterpretedOption_NamePart] {
        self.name.as_slice()
    }

    // optional string identifier_value = 3;

    pub fn clear_identifier_value(&mut self) {
        self.identifier_value.clear();
    }

    pub fn has_identifier_value(&self) -> bool {
        self.identifier_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_identifier_value(&mut self, v: ::std::string::String) {
        self.identifier_value = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_identifier_value(&'a mut self) -> &'a mut ::std::string::String {
        if self.identifier_value.is_none() {
            self.identifier_value.set_default();
        };
        self.identifier_value.as_mut().unwrap()
    }

    pub fn get_identifier_value(&'a self) -> &'a str {
        match self.identifier_value.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional uint64 positive_int_value = 4;

    pub fn clear_positive_int_value(&mut self) {
        self.positive_int_value = None;
    }

    pub fn has_positive_int_value(&self) -> bool {
        self.positive_int_value.is_some()
    }

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

    pub fn get_positive_int_value(&self) -> u64 {
        self.positive_int_value.unwrap_or(0)
    }

    // optional int64 negative_int_value = 5;

    pub fn clear_negative_int_value(&mut self) {
        self.negative_int_value = None;
    }

    pub fn has_negative_int_value(&self) -> bool {
        self.negative_int_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_negative_int_value(&mut self, v: i64) {
        self.negative_int_value = Some(v);
    }

    pub fn get_negative_int_value(&self) -> i64 {
        self.negative_int_value.unwrap_or(0)
    }

    // optional double double_value = 6;

    pub fn clear_double_value(&mut self) {
        self.double_value = None;
    }

    pub fn has_double_value(&self) -> bool {
        self.double_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_double_value(&mut self, v: f64) {
        self.double_value = Some(v);
    }

    pub fn get_double_value(&self) -> f64 {
        self.double_value.unwrap_or(0.)
    }

    // optional bytes string_value = 7;

    pub fn clear_string_value(&mut self) {
        self.string_value.clear();
    }

    pub fn has_string_value(&self) -> bool {
        self.string_value.is_some()
    }

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

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

    pub fn get_string_value(&'a self) -> &'a [u8] {
        match self.string_value.as_ref() {
            Some(v) => v.as_slice(),
            None => [].as_slice(),
        }
    }

    // optional string aggregate_value = 8;

    pub fn clear_aggregate_value(&mut self) {
        self.aggregate_value.clear();
    }

    pub fn has_aggregate_value(&self) -> bool {
        self.aggregate_value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_aggregate_value(&mut self, v: ::std::string::String) {
        self.aggregate_value = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_aggregate_value(&'a mut self) -> &'a mut ::std::string::String {
        if self.aggregate_value.is_none() {
            self.aggregate_value.set_default();
        };
        self.aggregate_value.as_mut().unwrap()
    }

    pub fn get_aggregate_value(&'a self) -> &'a str {
        match self.aggregate_value.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }
}

impl ::protobuf::Message for UninterpretedOption {
    fn new() -> UninterpretedOption {
        UninterpretedOption::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name.push_default();
                    try!(is.merge_message(tmp))
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.identifier_value.set_default();
                    try!(is.read_string_into(tmp))
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_uint64());
                    self.positive_int_value = Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_int64());
                    self.negative_int_value = Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_double());
                    self.double_value = Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.string_value.set_default();
                    try!(is.read_bytes_into(tmp))
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.aggregate_value.set_default();
                    try!(is.read_string_into(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in self.identifier_value.iter() {
            my_size += ::protobuf::rt::string_size(3, value.as_slice());
        };
        for value in self.positive_int_value.iter() {
            my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        for value in self.negative_int_value.iter() {
            my_size += ::protobuf::rt::value_size(5, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if self.double_value.is_some() {
            my_size += 9;
        };
        for value in self.string_value.iter() {
            my_size += ::protobuf::rt::bytes_size(7, value.as_slice());
        };
        for value in self.aggregate_value.iter() {
            my_size += ::protobuf::rt::string_size(8, value.as_slice());
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        for v in self.name.iter() {
            try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        match self.identifier_value.as_ref() {
            Some(v) => {
                try!(os.write_string(3, v.as_slice()));
            },
            None => {},
        };
        match self.positive_int_value {
            Some(v) => {
                try!(os.write_uint64(4, v));
            },
            None => {},
        };
        match self.negative_int_value {
            Some(v) => {
                try!(os.write_int64(5, v));
            },
            None => {},
        };
        match self.double_value {
            Some(v) => {
                try!(os.write_double(6, v));
            },
            None => {},
        };
        match self.string_value.as_ref() {
            Some(v) => {
                try!(os.write_bytes(7, v.as_slice()));
            },
            None => {},
        };
        match self.aggregate_value.as_ref() {
            Some(v) => {
                try!(os.write_string(8, v.as_slice()));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<UninterpretedOption>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_name_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_identifier_value_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_positive_int_value_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_negative_int_value_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_double_value_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_string_value_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_aggregate_value_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption>) });
                ::protobuf::reflect::MessageDescriptor::new::<UninterpretedOption>(
                    "UninterpretedOption",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<UninterpretedOption>()
    }
}

impl ::protobuf::Clear for UninterpretedOption {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_identifier_value();
        self.clear_positive_int_value();
        self.clear_negative_int_value();
        self.clear_double_value();
        self.clear_string_value();
        self.clear_aggregate_value();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for UninterpretedOption {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct UninterpretedOption_name_acc_type;
static UninterpretedOption_name_acc: UninterpretedOption_name_acc_type = UninterpretedOption_name_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_name_acc_type {
    fn name(&self) -> &'static str {
        "name"
    }

    fn len_field(&self, m: &UninterpretedOption) -> uint {
        m.get_name().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a UninterpretedOption, index: uint) -> &'a ::protobuf::Message {
        &m.get_name()[index] as &'a ::protobuf::Message
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_identifier_value_acc_type;
static UninterpretedOption_identifier_value_acc: UninterpretedOption_identifier_value_acc_type = UninterpretedOption_identifier_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_identifier_value_acc_type {
    fn name(&self) -> &'static str {
        "identifier_value"
    }

    fn has_field(&self, m: &UninterpretedOption) -> bool {
        m.has_identifier_value()
    }

    fn get_str<'a>(&self, m: &'a UninterpretedOption) -> &'a str {
        m.get_identifier_value()
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_positive_int_value_acc_type;
static UninterpretedOption_positive_int_value_acc: UninterpretedOption_positive_int_value_acc_type = UninterpretedOption_positive_int_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_positive_int_value_acc_type {
    fn name(&self) -> &'static str {
        "positive_int_value"
    }

    fn has_field(&self, m: &UninterpretedOption) -> bool {
        m.has_positive_int_value()
    }

    fn get_u64(&self, m: &UninterpretedOption) -> u64 {
        m.get_positive_int_value()
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_negative_int_value_acc_type;
static UninterpretedOption_negative_int_value_acc: UninterpretedOption_negative_int_value_acc_type = UninterpretedOption_negative_int_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_negative_int_value_acc_type {
    fn name(&self) -> &'static str {
        "negative_int_value"
    }

    fn has_field(&self, m: &UninterpretedOption) -> bool {
        m.has_negative_int_value()
    }

    fn get_i64(&self, m: &UninterpretedOption) -> i64 {
        m.get_negative_int_value()
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_double_value_acc_type;
static UninterpretedOption_double_value_acc: UninterpretedOption_double_value_acc_type = UninterpretedOption_double_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_double_value_acc_type {
    fn name(&self) -> &'static str {
        "double_value"
    }

    fn has_field(&self, m: &UninterpretedOption) -> bool {
        m.has_double_value()
    }

    fn get_f64(&self, m: &UninterpretedOption) -> f64 {
        m.get_double_value()
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_string_value_acc_type;
static UninterpretedOption_string_value_acc: UninterpretedOption_string_value_acc_type = UninterpretedOption_string_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_string_value_acc_type {
    fn name(&self) -> &'static str {
        "string_value"
    }

    fn has_field(&self, m: &UninterpretedOption) -> bool {
        m.has_string_value()
    }

    fn get_bytes<'a>(&self, m: &'a UninterpretedOption) -> &'a [u8] {
        m.get_string_value()
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_aggregate_value_acc_type;
static UninterpretedOption_aggregate_value_acc: UninterpretedOption_aggregate_value_acc_type = UninterpretedOption_aggregate_value_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption> for UninterpretedOption_aggregate_value_acc_type {
    fn name(&self) -> &'static str {
        "aggregate_value"
    }

    fn has_field(&self, m: &UninterpretedOption) -> bool {
        m.has_aggregate_value()
    }

    fn get_str<'a>(&self, m: &'a UninterpretedOption) -> &'a str {
        m.get_aggregate_value()
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct UninterpretedOption_NamePart {
    name_part: ::protobuf::SingularField<::std::string::String>,
    is_extension: ::std::option::Option<bool>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> UninterpretedOption_NamePart {
    pub fn new() -> UninterpretedOption_NamePart {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static UninterpretedOption_NamePart {
        static mut instance: ::protobuf::lazy::Lazy<UninterpretedOption_NamePart> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const UninterpretedOption_NamePart };
        unsafe {
            instance.get(|| {
                UninterpretedOption_NamePart {
                    name_part: ::protobuf::SingularField::none(),
                    is_extension: ::std::option::None,
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // required string name_part = 1;

    pub fn clear_name_part(&mut self) {
        self.name_part.clear();
    }

    pub fn has_name_part(&self) -> bool {
        self.name_part.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name_part(&mut self, v: ::std::string::String) {
        self.name_part = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name_part(&'a mut self) -> &'a mut ::std::string::String {
        if self.name_part.is_none() {
            self.name_part.set_default();
        };
        self.name_part.as_mut().unwrap()
    }

    pub fn get_name_part(&'a self) -> &'a str {
        match self.name_part.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // required bool is_extension = 2;

    pub fn clear_is_extension(&mut self) {
        self.is_extension = None;
    }

    pub fn has_is_extension(&self) -> bool {
        self.is_extension.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_extension(&mut self, v: bool) {
        self.is_extension = Some(v);
    }

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

impl ::protobuf::Message for UninterpretedOption_NamePart {
    fn new() -> UninterpretedOption_NamePart {
        UninterpretedOption_NamePart::new()
    }

    fn is_initialized(&self) -> bool {
        if self.name_part.is_none() {
            return false;
        };
        if self.is_extension.is_none() {
            return false;
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.name_part.set_default();
                    try!(is.read_string_into(tmp))
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = try!(is.read_bool());
                    self.is_extension = Some(tmp);
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.name_part.iter() {
            my_size += ::protobuf::rt::string_size(1, value.as_slice());
        };
        if self.is_extension.is_some() {
            my_size += 2;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    #[allow(unused_variables)]
    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        match self.name_part.as_ref() {
            Some(v) => {
                try!(os.write_string(1, v.as_slice()));
            },
            None => {},
        };
        match self.is_extension {
            Some(v) => {
                try!(os.write_bool(2, v));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<UninterpretedOption_NamePart>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<UninterpretedOption_NamePart>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_NamePart_name_part_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption_NamePart>) });
                fields.push(unsafe { ::std::mem::transmute(&UninterpretedOption_NamePart_is_extension_acc as &'static ::protobuf::reflect::FieldAccessor<UninterpretedOption_NamePart>) });
                ::protobuf::reflect::MessageDescriptor::new::<UninterpretedOption_NamePart>(
                    "UninterpretedOption_NamePart",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<UninterpretedOption_NamePart>()
    }
}

impl ::protobuf::Clear for UninterpretedOption_NamePart {
    fn clear(&mut self) {
        self.clear_name_part();
        self.clear_is_extension();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for UninterpretedOption_NamePart {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct UninterpretedOption_NamePart_name_part_acc_type;
static UninterpretedOption_NamePart_name_part_acc: UninterpretedOption_NamePart_name_part_acc_type = UninterpretedOption_NamePart_name_part_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption_NamePart> for UninterpretedOption_NamePart_name_part_acc_type {
    fn name(&self) -> &'static str {
        "name_part"
    }

    fn has_field(&self, m: &UninterpretedOption_NamePart) -> bool {
        m.has_name_part()
    }

    fn get_str<'a>(&self, m: &'a UninterpretedOption_NamePart) -> &'a str {
        m.get_name_part()
    }
}

#[allow(non_camel_case_types)]
struct UninterpretedOption_NamePart_is_extension_acc_type;
static UninterpretedOption_NamePart_is_extension_acc: UninterpretedOption_NamePart_is_extension_acc_type = UninterpretedOption_NamePart_is_extension_acc_type;

impl ::protobuf::reflect::FieldAccessor<UninterpretedOption_NamePart> for UninterpretedOption_NamePart_is_extension_acc_type {
    fn name(&self) -> &'static str {
        "is_extension"
    }

    fn has_field(&self, m: &UninterpretedOption_NamePart) -> bool {
        m.has_is_extension()
    }

    fn get_bool(&self, m: &UninterpretedOption_NamePart) -> bool {
        m.get_is_extension()
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct SourceCodeInfo {
    location: ::protobuf::RepeatedField<SourceCodeInfo_Location>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> SourceCodeInfo {
    pub fn new() -> SourceCodeInfo {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static SourceCodeInfo {
        static mut instance: ::protobuf::lazy::Lazy<SourceCodeInfo> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const SourceCodeInfo };
        unsafe {
            instance.get(|| {
                SourceCodeInfo {
                    location: ::protobuf::RepeatedField::new(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated .google.protobuf.SourceCodeInfo.Location location = 1;

    pub fn clear_location(&mut self) {
        self.location.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_location(&'a mut self) -> &'a mut ::protobuf::RepeatedField<SourceCodeInfo_Location> {
        &mut self.location
    }

    pub fn get_location(&'a self) -> &'a [SourceCodeInfo_Location] {
        self.location.as_slice()
    }
}

impl ::protobuf::Message for SourceCodeInfo {
    fn new() -> SourceCodeInfo {
        SourceCodeInfo::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.location.push_default();
                    try!(is.merge_message(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        for value in self.location.iter() {
            let len = value.compute_sizes(sizes);
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        for v in self.location.iter() {
            try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(sizes[*sizes_pos]));
            *sizes_pos += 1;
            try!(v.write_to_with_computed_sizes(os, sizes.as_slice(), sizes_pos));
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<SourceCodeInfo>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&SourceCodeInfo_location_acc as &'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo>) });
                ::protobuf::reflect::MessageDescriptor::new::<SourceCodeInfo>(
                    "SourceCodeInfo",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<SourceCodeInfo>()
    }
}

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

impl ::std::fmt::Show for SourceCodeInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct SourceCodeInfo_location_acc_type;
static SourceCodeInfo_location_acc: SourceCodeInfo_location_acc_type = SourceCodeInfo_location_acc_type;

impl ::protobuf::reflect::FieldAccessor<SourceCodeInfo> for SourceCodeInfo_location_acc_type {
    fn name(&self) -> &'static str {
        "location"
    }

    fn len_field(&self, m: &SourceCodeInfo) -> uint {
        m.get_location().len()
    }

    fn get_rep_message_item<'a>(&self, m: &'a SourceCodeInfo, index: uint) -> &'a ::protobuf::Message {
        &m.get_location()[index] as &'a ::protobuf::Message
    }
}

#[deriving(Clone,PartialEq,Default)]
pub struct SourceCodeInfo_Location {
    path: ::std::vec::Vec<i32>,
    span: ::std::vec::Vec<i32>,
    leading_comments: ::protobuf::SingularField<::std::string::String>,
    trailing_comments: ::protobuf::SingularField<::std::string::String>,
    unknown_fields: ::protobuf::UnknownFields,
}

impl<'a> SourceCodeInfo_Location {
    pub fn new() -> SourceCodeInfo_Location {
        ::std::default::Default::default()
    }

    pub fn default_instance() -> &'static SourceCodeInfo_Location {
        static mut instance: ::protobuf::lazy::Lazy<SourceCodeInfo_Location> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const SourceCodeInfo_Location };
        unsafe {
            instance.get(|| {
                SourceCodeInfo_Location {
                    path: ::std::vec::Vec::new(),
                    span: ::std::vec::Vec::new(),
                    leading_comments: ::protobuf::SingularField::none(),
                    trailing_comments: ::protobuf::SingularField::none(),
                    unknown_fields: ::protobuf::UnknownFields::new(),
                }
            })
        }
    }

    // repeated int32 path = 1;

    pub fn clear_path(&mut self) {
        self.path.clear();
    }

    // Param is passed by value, moved
    pub fn set_path(&mut self, v: ::std::vec::Vec<i32>) {
        self.path = v;
    }

    // Mutable pointer to the field.
    pub fn mut_path(&'a mut self) -> &'a mut ::std::vec::Vec<i32> {
        &mut self.path
    }

    pub fn get_path(&'a self) -> &'a [i32] {
        self.path.as_slice()
    }

    // repeated int32 span = 2;

    pub fn clear_span(&mut self) {
        self.span.clear();
    }

    // Param is passed by value, moved
    pub fn set_span(&mut self, v: ::std::vec::Vec<i32>) {
        self.span = v;
    }

    // Mutable pointer to the field.
    pub fn mut_span(&'a mut self) -> &'a mut ::std::vec::Vec<i32> {
        &mut self.span
    }

    pub fn get_span(&'a self) -> &'a [i32] {
        self.span.as_slice()
    }

    // optional string leading_comments = 3;

    pub fn clear_leading_comments(&mut self) {
        self.leading_comments.clear();
    }

    pub fn has_leading_comments(&self) -> bool {
        self.leading_comments.is_some()
    }

    // Param is passed by value, moved
    pub fn set_leading_comments(&mut self, v: ::std::string::String) {
        self.leading_comments = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_leading_comments(&'a mut self) -> &'a mut ::std::string::String {
        if self.leading_comments.is_none() {
            self.leading_comments.set_default();
        };
        self.leading_comments.as_mut().unwrap()
    }

    pub fn get_leading_comments(&'a self) -> &'a str {
        match self.leading_comments.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }

    // optional string trailing_comments = 4;

    pub fn clear_trailing_comments(&mut self) {
        self.trailing_comments.clear();
    }

    pub fn has_trailing_comments(&self) -> bool {
        self.trailing_comments.is_some()
    }

    // Param is passed by value, moved
    pub fn set_trailing_comments(&mut self, v: ::std::string::String) {
        self.trailing_comments = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_trailing_comments(&'a mut self) -> &'a mut ::std::string::String {
        if self.trailing_comments.is_none() {
            self.trailing_comments.set_default();
        };
        self.trailing_comments.as_mut().unwrap()
    }

    pub fn get_trailing_comments(&'a self) -> &'a str {
        match self.trailing_comments.as_ref() {
            Some(v) => v.as_slice(),
            None => "",
        }
    }
}

impl ::protobuf::Message for SourceCodeInfo_Location {
    fn new() -> SourceCodeInfo_Location {
        SourceCodeInfo_Location::new()
    }

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !try!(is.eof()) {
            let (field_number, wire_type) = try!(is.read_tag_unpack());
            match field_number {
                1 => {
                    if wire_type == ::protobuf::wire_format::WireTypeLengthDelimited {
                        let len = try!(is.read_raw_varint32());
                        let old_limit = is.push_limit(len);
                        while !try!(is.eof()) {
                            self.path.push(try!(is.read_int32()));
                        }
                        is.pop_limit(old_limit);
                    } else {
                        if wire_type != ::protobuf::wire_format::WireTypeVarint {
                            return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                        };
                        self.path.push(try!(is.read_int32()));
                    }
                },
                2 => {
                    if wire_type == ::protobuf::wire_format::WireTypeLengthDelimited {
                        let len = try!(is.read_raw_varint32());
                        let old_limit = is.push_limit(len);
                        while !try!(is.eof()) {
                            self.span.push(try!(is.read_int32()));
                        }
                        is.pop_limit(old_limit);
                    } else {
                        if wire_type != ::protobuf::wire_format::WireTypeVarint {
                            return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                        };
                        self.span.push(try!(is.read_int32()));
                    }
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.leading_comments.set_default();
                    try!(is.read_string_into(tmp))
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Err(::protobuf::ProtobufError::WireError("unexpected wire type".to_string()));
                    };
                    let tmp = self.trailing_comments.set_default();
                    try!(is.read_string_into(tmp))
                },
                _ => {
                    let unknown = try!(is.read_unknown(wire_type));
                    self.mut_unknown_fields().add_value(field_number, unknown);
                },
            };
        }
        ::std::result::Ok(())
    }

    // Compute sizes of nested messages
    fn compute_sizes(&self, sizes: &mut ::std::vec::Vec<u32>) -> u32 {
        use protobuf::{Message};
        let pos = sizes.len();
        sizes.push(0);
        let mut my_size = 0;
        if !self.path.is_empty() {
            my_size += ::protobuf::rt::vec_packed_varint_size(1, self.path.as_slice());
        };
        if !self.span.is_empty() {
            my_size += ::protobuf::rt::vec_packed_varint_size(2, self.span.as_slice());
        };
        for value in self.leading_comments.iter() {
            my_size += ::protobuf::rt::string_size(3, value.as_slice());
        };
        for value in self.trailing_comments.iter() {
            my_size += ::protobuf::rt::string_size(4, value.as_slice());
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        sizes[pos] = my_size;
        // value is returned for convenience
        my_size
    }

    #[allow(unused_variables)]
    fn write_to_with_computed_sizes(&self, os: &mut ::protobuf::CodedOutputStream, sizes: &[u32], sizes_pos: &mut uint) -> ::protobuf::ProtobufResult<()> {
        use protobuf::{Message};
        if !self.path.is_empty() {
            try!(os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(self.path.as_slice())));
            for v in self.path.iter() {
                try!(os.write_int32_no_tag(*v));
            };
        };
        if !self.span.is_empty() {
            try!(os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited));
            try!(os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(self.span.as_slice())));
            for v in self.span.iter() {
                try!(os.write_int32_no_tag(*v));
            };
        };
        match self.leading_comments.as_ref() {
            Some(v) => {
                try!(os.write_string(3, v.as_slice()));
            },
            None => {},
        };
        match self.trailing_comments.as_ref() {
            Some(v) => {
                try!(os.write_string(4, v.as_slice()));
            },
            None => {},
        };
        try!(os.write_unknown_fields(self.get_unknown_fields()));
        ::std::result::Ok(())
    }

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

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

    #[allow(unused_unsafe,unused_mut)]
    fn descriptor_static(_: ::std::option::Option<SourceCodeInfo_Location>) -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor };
        unsafe {
            descriptor.get(|| {
                let mut fields: ::std::vec::Vec<&'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location>> = ::std::vec::Vec::new();
                fields.push(unsafe { ::std::mem::transmute(&SourceCodeInfo_Location_path_acc as &'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location>) });
                fields.push(unsafe { ::std::mem::transmute(&SourceCodeInfo_Location_span_acc as &'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location>) });
                fields.push(unsafe { ::std::mem::transmute(&SourceCodeInfo_Location_leading_comments_acc as &'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location>) });
                fields.push(unsafe { ::std::mem::transmute(&SourceCodeInfo_Location_trailing_comments_acc as &'static ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location>) });
                ::protobuf::reflect::MessageDescriptor::new::<SourceCodeInfo_Location>(
                    "SourceCodeInfo_Location",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn type_id(&self) -> ::std::intrinsics::TypeId {
        ::std::intrinsics::TypeId::of::<SourceCodeInfo_Location>()
    }
}

impl ::protobuf::Clear for SourceCodeInfo_Location {
    fn clear(&mut self) {
        self.clear_path();
        self.clear_span();
        self.clear_leading_comments();
        self.clear_trailing_comments();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Show for SourceCodeInfo_Location {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use protobuf::{Message};
        self.fmt_impl(f)
    }
}


#[allow(non_camel_case_types)]
struct SourceCodeInfo_Location_path_acc_type;
static SourceCodeInfo_Location_path_acc: SourceCodeInfo_Location_path_acc_type = SourceCodeInfo_Location_path_acc_type;

impl ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location> for SourceCodeInfo_Location_path_acc_type {
    fn name(&self) -> &'static str {
        "path"
    }

    fn len_field(&self, m: &SourceCodeInfo_Location) -> uint {
        m.get_path().len()
    }

    fn get_rep_i32<'a>(&self, m: &'a SourceCodeInfo_Location) -> &'a [i32] {
        m.get_path()
    }
}

#[allow(non_camel_case_types)]
struct SourceCodeInfo_Location_span_acc_type;
static SourceCodeInfo_Location_span_acc: SourceCodeInfo_Location_span_acc_type = SourceCodeInfo_Location_span_acc_type;

impl ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location> for SourceCodeInfo_Location_span_acc_type {
    fn name(&self) -> &'static str {
        "span"
    }

    fn len_field(&self, m: &SourceCodeInfo_Location) -> uint {
        m.get_span().len()
    }

    fn get_rep_i32<'a>(&self, m: &'a SourceCodeInfo_Location) -> &'a [i32] {
        m.get_span()
    }
}

#[allow(non_camel_case_types)]
struct SourceCodeInfo_Location_leading_comments_acc_type;
static SourceCodeInfo_Location_leading_comments_acc: SourceCodeInfo_Location_leading_comments_acc_type = SourceCodeInfo_Location_leading_comments_acc_type;

impl ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location> for SourceCodeInfo_Location_leading_comments_acc_type {
    fn name(&self) -> &'static str {
        "leading_comments"
    }

    fn has_field(&self, m: &SourceCodeInfo_Location) -> bool {
        m.has_leading_comments()
    }

    fn get_str<'a>(&self, m: &'a SourceCodeInfo_Location) -> &'a str {
        m.get_leading_comments()
    }
}

#[allow(non_camel_case_types)]
struct SourceCodeInfo_Location_trailing_comments_acc_type;
static SourceCodeInfo_Location_trailing_comments_acc: SourceCodeInfo_Location_trailing_comments_acc_type = SourceCodeInfo_Location_trailing_comments_acc_type;

impl ::protobuf::reflect::FieldAccessor<SourceCodeInfo_Location> for SourceCodeInfo_Location_trailing_comments_acc_type {
    fn name(&self) -> &'static str {
        "trailing_comments"
    }

    fn has_field(&self, m: &SourceCodeInfo_Location) -> bool {
        m.has_trailing_comments()
    }

    fn get_str<'a>(&self, m: &'a SourceCodeInfo_Location) -> &'a str {
        m.get_trailing_comments()
    }
}

static file_descriptor_proto_data: &'static [u8] = &[
    0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
    0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f,
    0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
    0x62, 0x75, 0x66, 0x22, 0x47, 0x0a, 0x11, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
    0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x32, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65,
    0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
    0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73,
    0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcb, 0x03, 0x0a,
    0x13, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
    0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
    0x28, 0x09, 0x12, 0x0f, 0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20,
    0x01, 0x28, 0x09, 0x12, 0x12, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63,
    0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x12, 0x19, 0x0a, 0x11, 0x70, 0x75, 0x62, 0x6c, 0x69,
    0x63, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0a, 0x20, 0x03,
    0x28, 0x05, 0x12, 0x17, 0x0a, 0x0f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e,
    0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x12, 0x36, 0x0a, 0x0c, 0x6d,
    0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28,
    0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
    0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
    0x6f, 0x74, 0x6f, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65,
    0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
    0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73,
    0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x38, 0x0a, 0x07,
    0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
    0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
    0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
    0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x38, 0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
    0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
    0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c,
    0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
    0x12, 0x2d, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28,
    0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
    0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12,
    0x39, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69,
    0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
    0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72,
    0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0xa9, 0x03, 0x0a, 0x0f, 0x44,
    0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c,
    0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x34, 0x0a, 0x05,
    0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f,
    0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69,
    0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f,
    0x74, 0x6f, 0x12, 0x38, 0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18,
    0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
    0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73,
    0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x35, 0x0a, 0x0b,
    0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28,
    0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
    0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
    0x6f, 0x74, 0x6f, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65,
    0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
    0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73,
    0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x48, 0x0a, 0x0f,
    0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18,
    0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
    0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
    0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
    0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
    0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
    0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
    0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x2c, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65,
    0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x0d, 0x0a, 0x05, 0x73, 0x74,
    0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x12, 0x0b, 0x0a, 0x03, 0x65, 0x6e, 0x64,
    0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x22, 0x94, 0x05, 0x0a, 0x14, 0x46, 0x69, 0x65, 0x6c, 0x64,
    0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
    0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0e, 0x0a,
    0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x12, 0x3a, 0x0a,
    0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67,
    0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46,
    0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
    0x6f, 0x74, 0x6f, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x04, 0x74, 0x79, 0x70,
    0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
    0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44,
    0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54,
    0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x09, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
    0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x12, 0x10, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64,
    0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x12, 0x15, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61,
    0x75, 0x6c, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x12,
    0x2e, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b,
    0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
    0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22,
    0xb6, 0x02, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45,
    0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50,
    0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50,
    0x45, 0x5f, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50,
    0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59,
    0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59,
    0x50, 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c,
    0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x07, 0x12, 0x0d,
    0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a,
    0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0e,
    0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0a, 0x12, 0x10,
    0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x0b,
    0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x0c,
    0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10,
    0x0d, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e,
    0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33,
    0x32, 0x10, 0x0f, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58,
    0x45, 0x44, 0x36, 0x34, 0x10, 0x10, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53,
    0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f,
    0x53, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x12, 0x22, 0x43, 0x0a, 0x05, 0x4c, 0x61, 0x62, 0x65,
    0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f,
    0x4e, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52,
    0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42,
    0x45, 0x4c, 0x5f, 0x52, 0x45, 0x50, 0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x22, 0x8c, 0x01,
    0x0a, 0x13, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
    0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
    0x01, 0x28, 0x09, 0x12, 0x38, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x03,
    0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
    0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65,
    0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x2d, 0x0a,
    0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
    0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
    0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x6c, 0x0a, 0x18,
    0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
    0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
    0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0e, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
    0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x12, 0x32, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
    0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
    0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61,
    0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x16, 0x53,
    0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
    0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
    0x01, 0x28, 0x09, 0x12, 0x36, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x02, 0x20,
    0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
    0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63,
    0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x30, 0x0a, 0x07, 0x6f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67,
    0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53,
    0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x7f, 0x0a,
    0x15, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
    0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01,
    0x20, 0x01, 0x28, 0x09, 0x12, 0x12, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79,
    0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x12, 0x13, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70,
    0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x12, 0x2f, 0x0a,
    0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e,
    0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
    0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xe9,
    0x03, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14,
    0x0a, 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x01,
    0x20, 0x01, 0x28, 0x09, 0x12, 0x1c, 0x0a, 0x14, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74,
    0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01,
    0x28, 0x09, 0x12, 0x22, 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69,
    0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a,
    0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x1d, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x67,
    0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x5f, 0x61,
    0x6e, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66,
    0x61, 0x6c, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65,
    0x5f, 0x66, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f,
    0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c,
    0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a,
    0x65, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x12, 0x12, 0x0a, 0x0a,
    0x67, 0x6f, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09,
    0x12, 0x22, 0x0a, 0x13, 0x63, 0x63, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73,
    0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66,
    0x61, 0x6c, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x15, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e,
    0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x11, 0x20,
    0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x13, 0x70, 0x79,
    0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
    0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x43,
    0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
    0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
    0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d,
    0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0d,
    0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x5a, 0x45, 0x10, 0x02, 0x12, 0x10, 0x0a,
    0x0c, 0x4c, 0x49, 0x54, 0x45, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x03, 0x2a,
    0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xb8, 0x01, 0x0a, 0x0e, 0x4d,
    0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x26, 0x0a,
    0x17, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x72,
    0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05,
    0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x1f, 0x6e, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x6e,
    0x64, 0x61, 0x72, 0x64, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f,
    0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05,
    0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72,
    0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07,
    0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
    0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72,
    0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10,
    0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xbe, 0x02, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3a, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x18,
    0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
    0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x43, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x06, 0x53, 0x54, 0x52, 0x49,
    0x4e, 0x47, 0x12, 0x0e, 0x0a, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01,
    0x28, 0x08, 0x12, 0x13, 0x0a, 0x04, 0x6c, 0x61, 0x7a, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08,
    0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65,
    0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
    0x73, 0x65, 0x12, 0x1c, 0x0a, 0x14, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74,
    0x61, 0x6c, 0x5f, 0x6d, 0x61, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09,
    0x12, 0x13, 0x0a, 0x04, 0x77, 0x65, 0x61, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05,
    0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72,
    0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07,
    0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
    0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72,
    0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2f, 0x0a, 0x05, 0x43, 0x54,
    0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12,
    0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x52,
    0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, 0x43, 0x45, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07,
    0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x78, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70,
    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x19, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x61,
    0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65,
    0x12, 0x43, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65,
    0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32,
    0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
    0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02,
    0x22, 0x62, 0x0a, 0x10, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x73, 0x12, 0x43, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70,
    0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20,
    0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
    0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
    0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80,
    0x80, 0x80, 0x80, 0x02, 0x22, 0x60, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x43, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65,
    0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7,
    0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
    0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70,
    0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07,
    0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x5f, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
    0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x43, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74,
    0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18,
    0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
    0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72,
    0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8,
    0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x9e, 0x02, 0x0a, 0x13, 0x55, 0x6e, 0x69, 0x6e,
    0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12,
    0x3b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e,
    0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
    0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x12, 0x18, 0x0a, 0x10,
    0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
    0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x12, 0x1a, 0x0a, 0x12, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
    0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01,
    0x28, 0x04, 0x12, 0x1a, 0x0a, 0x12, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69,
    0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x12, 0x14,
    0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06,
    0x20, 0x01, 0x28, 0x01, 0x12, 0x14, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76,
    0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x12, 0x17, 0x0a, 0x0f, 0x61, 0x67,
    0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20,
    0x01, 0x28, 0x09, 0x1a, 0x33, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x12,
    0x11, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x02,
    0x28, 0x09, 0x12, 0x14, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
    0x6f, 0x6e, 0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x22, 0xb1, 0x01, 0x0a, 0x0e, 0x53, 0x6f, 0x75,
    0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3a, 0x0a, 0x08, 0x6c,
    0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e,
    0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
    0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4c,
    0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x63, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74,
    0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28,
    0x05, 0x42, 0x02, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x18, 0x02, 0x20,
    0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x10, 0x6c, 0x65, 0x61, 0x64, 0x69,
    0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28,
    0x09, 0x12, 0x19, 0x0a, 0x11, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f,
    0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x29, 0x0a, 0x13,
    0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
    0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
    0x72, 0x6f, 0x74, 0x6f, 0x73, 0x48, 0x01, 0x4a, 0xb7, 0xbd, 0x01, 0x0a, 0x07, 0x12, 0x05, 0x28,
    0x00, 0xeb, 0x04, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x28, 0x08, 0x17, 0x0a, 0x08,
    0x0a, 0x01, 0x08, 0x12, 0x03, 0x29, 0x00, 0x2c, 0x0a, 0x0b, 0x0a, 0x04, 0x08, 0xe7, 0x07, 0x00,
    0x12, 0x03, 0x29, 0x00, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x12, 0x03,
    0x29, 0x07, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x00, 0x12, 0x03, 0x29,
    0x07, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x29,
    0x07, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x08, 0xe7, 0x07, 0x00, 0x07, 0x12, 0x03, 0x29, 0x16, 0x2b,
    0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x2a, 0x00, 0x31, 0x0a, 0x0b, 0x0a, 0x04, 0x08, 0xe7,
    0x07, 0x01, 0x12, 0x03, 0x2a, 0x00, 0x31, 0x0a, 0x0c, 0x0a, 0x05, 0x08, 0xe7, 0x07, 0x01, 0x02,
    0x12, 0x03, 0x2a, 0x07, 0x1b, 0x0a, 0x0d, 0x0a, 0x06, 0x08, 0xe7, 0x07, 0x01, 0x02, 0x00, 0x12,
    0x03, 0x2a, 0x07, 0x1b, 0x0a, 0x0e, 0x0a, 0x07, 0x08, 0xe7, 0x07, 0x01, 0x02, 0x00, 0x01, 0x12,
    0x03, 0x2a, 0x07, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x08, 0xe7, 0x07, 0x01, 0x07, 0x12, 0x03, 0x2a,
    0x1e, 0x30, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x2e, 0x00, 0x1c, 0x0a, 0x81, 0x01, 0x0a,
    0x04, 0x08, 0xe7, 0x07, 0x02, 0x12, 0x03, 0x2e, 0x00, 0x1c, 0x1a, 0x74, 0x20, 0x64, 0x65, 0x73,
    0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x6d, 0x75,
    0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x20,
    0x66, 0x6f, 0x72, 0x20, 0x73, 0x70, 0x65, 0x65, 0x64, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73,
    0x65, 0x20, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x62, 0x61, 0x73,
    0x65, 0x64, 0x0a, 0x20, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x73, 0x20, 0x64,
    0x6f, 0x6e, 0x27, 0x74, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67,
    0x20, 0x62, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x2e, 0x0a,
    0x0a, 0x0c, 0x0a, 0x05, 0x08, 0xe7, 0x07, 0x02, 0x02, 0x12, 0x03, 0x2e, 0x07, 0x13, 0x0a, 0x0d,
    0x0a, 0x06, 0x08, 0xe7, 0x07, 0x02, 0x02, 0x00, 0x12, 0x03, 0x2e, 0x07, 0x13, 0x0a, 0x0e, 0x0a,
    0x07, 0x08, 0xe7, 0x07, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2e, 0x07, 0x13, 0x0a, 0x0c, 0x0a,
    0x05, 0x08, 0xe7, 0x07, 0x02, 0x03, 0x12, 0x03, 0x2e, 0x16, 0x1b, 0x0a, 0x6a, 0x0a, 0x02, 0x04,
    0x00, 0x12, 0x04, 0x32, 0x00, 0x34, 0x01, 0x1a, 0x5e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x72,
    0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20,
    0x63, 0x61, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x61, 0x20, 0x46, 0x69, 0x6c,
    0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x20, 0x63,
    0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x2e, 0x70,
    0x72, 0x6f, 0x74, 0x6f, 0x0a, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x69, 0x74, 0x20, 0x70,
    0x61, 0x72, 0x73, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03,
    0x32, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x33, 0x02, 0x28,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x33, 0x02, 0x0a, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x33, 0x0b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05,
    0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x33, 0x1f, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00,
    0x02, 0x00, 0x03, 0x12, 0x03, 0x33, 0x26, 0x27, 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04,
    0x37, 0x00, 0x50, 0x01, 0x1a, 0x23, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73,
    0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x2e, 0x70, 0x72, 0x6f,
    0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01,
    0x12, 0x03, 0x37, 0x08, 0x1b, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x38,
    0x02, 0x1b, 0x22, 0x2c, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20,
    0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x72, 0x6f, 0x6f, 0x74,
    0x20, 0x6f, 0x66, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x74, 0x72, 0x65, 0x65, 0x0a,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x38, 0x02, 0x0a, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x38, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05,
    0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x38, 0x12, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01,
    0x02, 0x00, 0x03, 0x12, 0x03, 0x38, 0x19, 0x1a, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01,
    0x12, 0x03, 0x39, 0x02, 0x1e, 0x22, 0x1d, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x22, 0x66, 0x6f,
    0x6f, 0x22, 0x2c, 0x20, 0x22, 0x66, 0x6f, 0x6f, 0x2e, 0x62, 0x61, 0x72, 0x22, 0x2c, 0x20, 0x65,
    0x74, 0x63, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x39,
    0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x39, 0x0b, 0x11,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x39, 0x12, 0x19, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x39, 0x1c, 0x1d, 0x0a, 0x34, 0x0a, 0x04,
    0x04, 0x01, 0x02, 0x02, 0x12, 0x03, 0x3c, 0x02, 0x21, 0x1a, 0x27, 0x20, 0x4e, 0x61, 0x6d, 0x65,
    0x73, 0x20, 0x6f, 0x66, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72,
    0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65,
    0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x3c, 0x02, 0x0a,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x3c, 0x0b, 0x11, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3c, 0x12, 0x1c, 0x0a, 0x0c, 0x0a, 0x05,
    0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x3c, 0x1f, 0x20, 0x0a, 0x51, 0x0a, 0x04, 0x04, 0x01,
    0x02, 0x03, 0x12, 0x03, 0x3e, 0x02, 0x28, 0x1a, 0x44, 0x20, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65,
    0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20,
    0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79,
    0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a,
    0x05, 0x04, 0x01, 0x02, 0x03, 0x04, 0x12, 0x03, 0x3e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04,
    0x01, 0x02, 0x03, 0x05, 0x12, 0x03, 0x3e, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02,
    0x03, 0x01, 0x12, 0x03, 0x3e, 0x11, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03,
    0x12, 0x03, 0x3e, 0x25, 0x27, 0x0a, 0x7a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x41,
    0x02, 0x26, 0x1a, 0x6d, 0x20, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x77, 0x65, 0x61, 0x6b, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65,
    0x64, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64,
    0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x0a,
    0x20, 0x46, 0x6f, 0x72, 0x20, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2d, 0x69, 0x6e, 0x74, 0x65,
    0x72, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f,
    0x6e, 0x6c, 0x79, 0x2e, 0x20, 0x44, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, 0x2e,
    0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x04, 0x12, 0x03, 0x41, 0x02, 0x0a, 0x0a,
    0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, 0x03, 0x41, 0x0b, 0x10, 0x0a, 0x0c, 0x0a,
    0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x41, 0x11, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04,
    0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x41, 0x23, 0x25, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x01, 0x02,
    0x05, 0x12, 0x03, 0x44, 0x02, 0x2c, 0x1a, 0x29, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x74, 0x6f, 0x70,
    0x2d, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f,
    0x6e, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e,
    0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x04, 0x12, 0x03, 0x44, 0x02, 0x0a, 0x0a,
    0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x05, 0x06, 0x12, 0x03, 0x44, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a,
    0x05, 0x04, 0x01, 0x02, 0x05, 0x01, 0x12, 0x03, 0x44, 0x1b, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04,
    0x01, 0x02, 0x05, 0x03, 0x12, 0x03, 0x44, 0x2a, 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02,
    0x06, 0x12, 0x03, 0x45, 0x02, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x04, 0x12,
    0x03, 0x45, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x06, 0x12, 0x03, 0x45,
    0x0b, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x01, 0x12, 0x03, 0x45, 0x1f, 0x28,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x06, 0x03, 0x12, 0x03, 0x45, 0x2b, 0x2c, 0x0a, 0x0b,
    0x0a, 0x04, 0x04, 0x01, 0x02, 0x07, 0x12, 0x03, 0x46, 0x02, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04,
    0x01, 0x02, 0x07, 0x04, 0x12, 0x03, 0x46, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02,
    0x07, 0x06, 0x12, 0x03, 0x46, 0x0b, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x01,
    0x12, 0x03, 0x46, 0x22, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x07, 0x03, 0x12, 0x03,
    0x46, 0x2c, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x08, 0x12, 0x03, 0x47, 0x02, 0x2e,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x04, 0x12, 0x03, 0x47, 0x02, 0x0a, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x01, 0x02, 0x08, 0x06, 0x12, 0x03, 0x47, 0x0b, 0x1f, 0x0a, 0x0c, 0x0a, 0x05,
    0x04, 0x01, 0x02, 0x08, 0x01, 0x12, 0x03, 0x47, 0x20, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01,
    0x02, 0x08, 0x03, 0x12, 0x03, 0x47, 0x2c, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x09,
    0x12, 0x03, 0x49, 0x02, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x04, 0x12, 0x03,
    0x49, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x06, 0x12, 0x03, 0x49, 0x0b,
    0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x01, 0x12, 0x03, 0x49, 0x17, 0x1e, 0x0a,
    0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x09, 0x03, 0x12, 0x03, 0x49, 0x21, 0x22, 0x0a, 0xf5, 0x01,
    0x0a, 0x04, 0x04, 0x01, 0x02, 0x0a, 0x12, 0x03, 0x4f, 0x02, 0x2f, 0x1a, 0xe7, 0x01, 0x20, 0x54,
    0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69,
    0x6e, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x66, 0x6f,
    0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63,
    0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x2e, 0x0a, 0x20, 0x59, 0x6f, 0x75, 0x20, 0x6d, 0x61, 0x79,
    0x20, 0x73, 0x61, 0x66, 0x65, 0x6c, 0x79, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x74,
    0x68, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64,
    0x20, 0x77, 0x68, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x68, 0x61, 0x72, 0x6d, 0x69, 0x6e,
    0x67, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x0a, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
    0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x73, 0x20, 0x2d, 0x2d, 0x20, 0x74,
    0x68, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69,
    0x73, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x62, 0x79,
    0x0a, 0x20, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f,
    0x6f, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x04, 0x12, 0x03,
    0x4f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x4f, 0x0b,
    0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x4f, 0x1a, 0x2a, 0x0a,
    0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x4f, 0x2d, 0x2e, 0x0a, 0x27, 0x0a,
    0x02, 0x04, 0x02, 0x12, 0x04, 0x53, 0x00, 0x63, 0x01, 0x1a, 0x1b, 0x20, 0x44, 0x65, 0x73, 0x63,
    0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20,
    0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x53,
    0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x54, 0x02, 0x1b, 0x0a,
    0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x54, 0x02, 0x0a, 0x0a, 0x0c, 0x0a,
    0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x54, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04,
    0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x54, 0x12, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02,
    0x00, 0x03, 0x12, 0x03, 0x54, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12,
    0x03, 0x56, 0x02, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, 0x12, 0x03, 0x56,
    0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x56, 0x0b, 0x1f,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x56, 0x20, 0x25, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x56, 0x28, 0x29, 0x0a, 0x0b, 0x0a, 0x04,
    0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x57, 0x02, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02,
    0x02, 0x04, 0x12, 0x03, 0x57, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06,
    0x12, 0x03, 0x57, 0x0b, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03,
    0x57, 0x20, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x57, 0x2c,
    0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x59, 0x02, 0x2b, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x02, 0x02, 0x03, 0x04, 0x12, 0x03, 0x59, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05,
    0x04, 0x02, 0x02, 0x03, 0x06, 0x12, 0x03, 0x59, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02,
    0x02, 0x03, 0x01, 0x12, 0x03, 0x59, 0x1b, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x03,
    0x03, 0x12, 0x03, 0x59, 0x29, 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x03,
    0x5a, 0x02, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x04, 0x12, 0x03, 0x5a, 0x02,
    0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x06, 0x12, 0x03, 0x5a, 0x0b, 0x1e, 0x0a,
    0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x04, 0x01, 0x12, 0x03, 0x5a, 0x1f, 0x28, 0x0a, 0x0c, 0x0a,
    0x05, 0x04, 0x02, 0x02, 0x04, 0x03, 0x12, 0x03, 0x5a, 0x2b, 0x2c, 0x0a, 0x0c, 0x0a, 0x04, 0x04,
    0x02, 0x03, 0x00, 0x12, 0x04, 0x5c, 0x02, 0x5f, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x03,
    0x00, 0x01, 0x12, 0x03, 0x5c, 0x0a, 0x18, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x00, 0x02,
    0x00, 0x12, 0x03, 0x5d, 0x04, 0x1d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00,
    0x04, 0x12, 0x03, 0x5d, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00,
    0x05, 0x12, 0x03, 0x5d, 0x0d, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00,
    0x01, 0x12, 0x03, 0x5d, 0x13, 0x18, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00,
    0x03, 0x12, 0x03, 0x5d, 0x1b, 0x1c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01,
    0x12, 0x03, 0x5e, 0x04, 0x1b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x04,
    0x12, 0x03, 0x5e, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x05,
    0x12, 0x03, 0x5e, 0x0d, 0x12, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x01,
    0x12, 0x03, 0x5e, 0x13, 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x03,
    0x12, 0x03, 0x5e, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x05, 0x12, 0x03, 0x60,
    0x02, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x04, 0x12, 0x03, 0x60, 0x02, 0x0a,
    0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x06, 0x12, 0x03, 0x60, 0x0b, 0x19, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x02, 0x02, 0x05, 0x01, 0x12, 0x03, 0x60, 0x1a, 0x29, 0x0a, 0x0c, 0x0a, 0x05,
    0x04, 0x02, 0x02, 0x05, 0x03, 0x12, 0x03, 0x60, 0x2c, 0x2d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02,
    0x02, 0x06, 0x12, 0x03, 0x62, 0x02, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x04,
    0x12, 0x03, 0x62, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x06, 0x12, 0x03,
    0x62, 0x0b, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x01, 0x12, 0x03, 0x62, 0x1a,
    0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x06, 0x03, 0x12, 0x03, 0x62, 0x24, 0x25, 0x0a,
    0x32, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x05, 0x66, 0x00, 0xa7, 0x01, 0x01, 0x1a, 0x25, 0x20, 0x44,
    0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64,
    0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
    0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x66, 0x08, 0x1c, 0x0a,
    0x0d, 0x0a, 0x04, 0x04, 0x03, 0x04, 0x00, 0x12, 0x05, 0x67, 0x02, 0x82, 0x01, 0x03, 0x0a, 0x0c,
    0x0a, 0x05, 0x04, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x67, 0x07, 0x0b, 0x0a, 0x52, 0x0a, 0x06,
    0x04, 0x03, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x6a, 0x04, 0x1c, 0x1a, 0x43, 0x20, 0x30, 0x20,
    0x69, 0x73, 0x20, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20,
    0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x2e, 0x0a, 0x20, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x69,
    0x73, 0x20, 0x77, 0x65, 0x69, 0x72, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x68, 0x69, 0x73, 0x74,
    0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x2e, 0x0a,
    0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6a, 0x04, 0x0f,
    0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x6a, 0x1a, 0x1b,
    0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x6b, 0x04, 0x1c, 0x0a,
    0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x6b, 0x04, 0x0e, 0x0a,
    0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x6b, 0x1a, 0x1b, 0x0a,
    0x76, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x6e, 0x04, 0x1c, 0x1a, 0x67,
    0x20, 0x4e, 0x6f, 0x74, 0x20, 0x5a, 0x69, 0x67, 0x5a, 0x61, 0x67, 0x20, 0x65, 0x6e, 0x63, 0x6f,
    0x64, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x4e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6e,
    0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x20, 0x31, 0x30, 0x20, 0x62,
    0x79, 0x74, 0x65, 0x73, 0x2e, 0x20, 0x20, 0x55, 0x73, 0x65, 0x20, 0x54, 0x59, 0x50, 0x45, 0x5f,
    0x53, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x20, 0x69, 0x66, 0x0a, 0x20, 0x6e, 0x65, 0x67, 0x61, 0x74,
    0x69, 0x76, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6c,
    0x69, 0x6b, 0x65, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x02, 0x01, 0x12, 0x03, 0x6e, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x02, 0x02, 0x12, 0x03, 0x6e, 0x1a, 0x1b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x03, 0x12, 0x03, 0x6f, 0x04, 0x1c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x03,
    0x01, 0x12, 0x03, 0x6f, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x03,
    0x02, 0x12, 0x03, 0x6f, 0x1a, 0x1b, 0x0a, 0x76, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x04,
    0x12, 0x03, 0x72, 0x04, 0x1c, 0x1a, 0x67, 0x20, 0x4e, 0x6f, 0x74, 0x20, 0x5a, 0x69, 0x67, 0x5a,
    0x61, 0x67, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x4e, 0x65, 0x67,
    0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x74, 0x61,
    0x6b, 0x65, 0x20, 0x31, 0x30, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2e, 0x20, 0x20, 0x55, 0x73,
    0x65, 0x20, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x20, 0x69, 0x66,
    0x0a, 0x20, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65,
    0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x2e, 0x0a, 0x0a, 0x0e,
    0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x72, 0x04, 0x0e, 0x0a, 0x0e,
    0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x72, 0x1a, 0x1b, 0x0a, 0x0d,
    0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x73, 0x04, 0x1c, 0x0a, 0x0e, 0x0a,
    0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x73, 0x04, 0x10, 0x0a, 0x0e, 0x0a,
    0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x05, 0x02, 0x12, 0x03, 0x73, 0x1a, 0x1b, 0x0a, 0x0d, 0x0a,
    0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x74, 0x04, 0x1c, 0x0a, 0x0e, 0x0a, 0x07,
    0x04, 0x03, 0x04, 0x00, 0x02, 0x06, 0x01, 0x12, 0x03, 0x74, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07,
    0x04, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 0x12, 0x03, 0x74, 0x1a, 0x1b, 0x0a, 0x0d, 0x0a, 0x06,
    0x04, 0x03, 0x04, 0x00, 0x02, 0x07, 0x12, 0x03, 0x75, 0x04, 0x1c, 0x0a, 0x0e, 0x0a, 0x07, 0x04,
    0x03, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x75, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04,
    0x03, 0x04, 0x00, 0x02, 0x07, 0x02, 0x12, 0x03, 0x75, 0x1a, 0x1b, 0x0a, 0x0d, 0x0a, 0x06, 0x04,
    0x03, 0x04, 0x00, 0x02, 0x08, 0x12, 0x03, 0x76, 0x04, 0x1c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03,
    0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x76, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03,
    0x04, 0x00, 0x02, 0x08, 0x02, 0x12, 0x03, 0x76, 0x1a, 0x1b, 0x0a, 0x29, 0x0a, 0x06, 0x04, 0x03,
    0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x77, 0x04, 0x1d, 0x22, 0x1a, 0x20, 0x54, 0x61, 0x67, 0x2d,
    0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67,
    0x61, 0x74, 0x65, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x09, 0x01,
    0x12, 0x03, 0x77, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x09, 0x02,
    0x12, 0x03, 0x77, 0x1a, 0x1c, 0x0a, 0x2c, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0a, 0x12,
    0x03, 0x78, 0x04, 0x1d, 0x22, 0x1d, 0x20, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x2d, 0x64, 0x65,
    0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74,
    0x65, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0a, 0x01, 0x12, 0x03,
    0x78, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0a, 0x02, 0x12, 0x03,
    0x78, 0x1a, 0x1c, 0x0a, 0x22, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0b, 0x12, 0x03, 0x7b,
    0x04, 0x1d, 0x1a, 0x13, 0x20, 0x4e, 0x65, 0x77, 0x20, 0x69, 0x6e, 0x20, 0x76, 0x65, 0x72, 0x73,
    0x69, 0x6f, 0x6e, 0x20, 0x32, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x0b, 0x01, 0x12, 0x03, 0x7b, 0x04, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x0b, 0x02, 0x12, 0x03, 0x7b, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x0c, 0x12, 0x03, 0x7c, 0x04, 0x1d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0c,
    0x01, 0x12, 0x03, 0x7c, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0c,
    0x02, 0x12, 0x03, 0x7c, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0d,
    0x12, 0x03, 0x7d, 0x04, 0x1d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0d, 0x01,
    0x12, 0x03, 0x7d, 0x04, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0d, 0x02,
    0x12, 0x03, 0x7d, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0e, 0x12,
    0x03, 0x7e, 0x04, 0x1d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0e, 0x01, 0x12,
    0x03, 0x7e, 0x04, 0x11, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0e, 0x02, 0x12,
    0x03, 0x7e, 0x1a, 0x1c, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0f, 0x12, 0x03,
    0x7f, 0x04, 0x1d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0f, 0x01, 0x12, 0x03,
    0x7f, 0x04, 0x11, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x0f, 0x02, 0x12, 0x03,
    0x7f, 0x1a, 0x1c, 0x0a, 0x27, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x10, 0x12, 0x04, 0x80,
    0x01, 0x04, 0x1d, 0x22, 0x17, 0x20, 0x55, 0x73, 0x65, 0x73, 0x20, 0x5a, 0x69, 0x67, 0x5a, 0x61,
    0x67, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07,
    0x04, 0x03, 0x04, 0x00, 0x02, 0x10, 0x01, 0x12, 0x04, 0x80, 0x01, 0x04, 0x0f, 0x0a, 0x0f, 0x0a,
    0x07, 0x04, 0x03, 0x04, 0x00, 0x02, 0x10, 0x02, 0x12, 0x04, 0x80, 0x01, 0x1a, 0x1c, 0x0a, 0x27,
    0x0a, 0x06, 0x04, 0x03, 0x04, 0x00, 0x02, 0x11, 0x12, 0x04, 0x81, 0x01, 0x04, 0x1d, 0x22, 0x17,
    0x20, 0x55, 0x73, 0x65, 0x73, 0x20, 0x5a, 0x69, 0x67, 0x5a, 0x61, 0x67, 0x20, 0x65, 0x6e, 0x63,
    0x6f, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00, 0x02,
    0x11, 0x01, 0x12, 0x04, 0x81, 0x01, 0x04, 0x0f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x00,
    0x02, 0x11, 0x02, 0x12, 0x04, 0x81, 0x01, 0x1a, 0x1c, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x03, 0x04,
    0x01, 0x12, 0x06, 0x84, 0x01, 0x02, 0x8a, 0x01, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x04,
    0x01, 0x01, 0x12, 0x04, 0x84, 0x01, 0x07, 0x0c, 0x0a, 0x2a, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x01,
    0x02, 0x00, 0x12, 0x04, 0x86, 0x01, 0x04, 0x1c, 0x1a, 0x1a, 0x20, 0x30, 0x20, 0x69, 0x73, 0x20,
    0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x72, 0x72,
    0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12,
    0x04, 0x86, 0x01, 0x04, 0x12, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x01, 0x02, 0x00, 0x02,
    0x12, 0x04, 0x86, 0x01, 0x1a, 0x1b, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x01, 0x02, 0x01,
    0x12, 0x04, 0x87, 0x01, 0x04, 0x1c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x01, 0x02, 0x01,
    0x01, 0x12, 0x04, 0x87, 0x01, 0x04, 0x12, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x01, 0x02,
    0x01, 0x02, 0x12, 0x04, 0x87, 0x01, 0x1a, 0x1b, 0x0a, 0x38, 0x0a, 0x06, 0x04, 0x03, 0x04, 0x01,
    0x02, 0x02, 0x12, 0x04, 0x88, 0x01, 0x04, 0x1c, 0x22, 0x28, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x28,
    0x73, 0x61, 0x6e, 0x6a, 0x61, 0x79, 0x29, 0x3a, 0x20, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20,
    0x77, 0x65, 0x20, 0x61, 0x64, 0x64, 0x20, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x4d, 0x41, 0x50,
    0x3f, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x04, 0x88,
    0x01, 0x04, 0x12, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x03, 0x04, 0x01, 0x02, 0x02, 0x02, 0x12, 0x04,
    0x88, 0x01, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x04, 0x8c, 0x01,
    0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x04, 0x8c, 0x01, 0x02,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x04, 0x8c, 0x01, 0x0b, 0x11,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8c, 0x01, 0x12, 0x16, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8c, 0x01, 0x19, 0x1a, 0x0a, 0x0c,
    0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x04, 0x8d, 0x01, 0x02, 0x1c, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x03, 0x02, 0x01, 0x04, 0x12, 0x04, 0x8d, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x03, 0x02, 0x01, 0x05, 0x12, 0x04, 0x8d, 0x01, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03,
    0x02, 0x01, 0x01, 0x12, 0x04, 0x8d, 0x01, 0x11, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02,
    0x01, 0x03, 0x12, 0x04, 0x8d, 0x01, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02,
    0x12, 0x04, 0x8e, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x04, 0x12,
    0x04, 0x8e, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x04,
    0x8e, 0x01, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x04, 0x8e,
    0x01, 0x11, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x03, 0x12, 0x04, 0x8e, 0x01,
    0x19, 0x1a, 0x0a, 0x90, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x04, 0x92, 0x01, 0x02,
    0x19, 0x1a, 0x81, 0x01, 0x20, 0x49, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
    0x65, 0x20, 0x69, 0x73, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e,
    0x65, 0x65, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x2e, 0x20,
    0x20, 0x49, 0x66, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6e,
    0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x20, 0x61, 0x72, 0x65,
    0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20,
    0x62, 0x65, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x45,
    0x4e, 0x55, 0x4d, 0x20, 0x6f, 0x72, 0x20, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4d, 0x45, 0x53, 0x53,
    0x41, 0x47, 0x45, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x04, 0x12, 0x04,
    0x92, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x06, 0x12, 0x04, 0x92,
    0x01, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, 0x04, 0x92, 0x01,
    0x10, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x12, 0x04, 0x92, 0x01, 0x17,
    0x18, 0x0a, 0xb7, 0x02, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x04, 0x99, 0x01, 0x02, 0x20,
    0x1a, 0xa8, 0x02, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20,
    0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2c, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65,
    0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x20, 0x20, 0x49,
    0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x20, 0x73, 0x74, 0x61, 0x72,
    0x74, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x27, 0x2e, 0x27, 0x2c, 0x20, 0x69,
    0x74, 0x20, 0x69, 0x73, 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x2d, 0x71, 0x75, 0x61, 0x6c, 0x69,
    0x66, 0x69, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65,
    0x2c, 0x20, 0x43, 0x2b, 0x2b, 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x69,
    0x6e, 0x67, 0x0a, 0x20, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, 0x73,
    0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
    0x79, 0x70, 0x65, 0x20, 0x28, 0x69, 0x2e, 0x65, 0x2e, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73,
    0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x6d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68,
    0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x2c, 0x20, 0x6f, 0x6e, 0x20, 0x75,
    0x70, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x0a, 0x20, 0x6e,
    0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x03, 0x02, 0x04, 0x04, 0x12, 0x04, 0x99, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03,
    0x02, 0x04, 0x05, 0x12, 0x04, 0x99, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02,
    0x04, 0x01, 0x12, 0x04, 0x99, 0x01, 0x12, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04,
    0x03, 0x12, 0x04, 0x99, 0x01, 0x1e, 0x1f, 0x0a, 0x7e, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x05, 0x12,
    0x04, 0x9d, 0x01, 0x02, 0x1f, 0x1a, 0x70, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65,
    0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x74, 0x79, 0x70, 0x65, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e,
    0x64, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x0a, 0x20, 0x72, 0x65, 0x73,
    0x6f, 0x6c, 0x76, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d,
    0x65, 0x20, 0x6d, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x61, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65,
    0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x04,
    0x12, 0x04, 0x9d, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x05, 0x12,
    0x04, 0x9d, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x01, 0x12, 0x04,
    0x9d, 0x01, 0x12, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x04, 0x9d,
    0x01, 0x1d, 0x1e, 0x0a, 0xb1, 0x02, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x06, 0x12, 0x04, 0xa4, 0x01,
    0x02, 0x24, 0x1a, 0xa2, 0x02, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x69,
    0x63, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
    0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x74,
    0x65, 0x78, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e,
    0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x73, 0x2c, 0x20,
    0x22, 0x74, 0x72, 0x75, 0x65, 0x22, 0x20, 0x6f, 0x72, 0x20, 0x22, 0x66, 0x61, 0x6c, 0x73, 0x65,
    0x22, 0x2e, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x2c,
    0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65,
    0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65,
    0x6e, 0x74, 0x73, 0x20, 0x28, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x64,
    0x20, 0x69, 0x6e, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x77, 0x61, 0x79, 0x29, 0x2e, 0x0a, 0x20, 0x46,
    0x6f, 0x72, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69,
    0x6e, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x20, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x64,
    0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x20, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x62, 0x79, 0x74,
    0x65, 0x73, 0x20, 0x3e, 0x3d, 0x20, 0x31, 0x32, 0x38, 0x20, 0x61, 0x72, 0x65, 0x20, 0x65, 0x73,
    0x63, 0x61, 0x70, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x28, 0x6b, 0x65, 0x6e,
    0x74, 0x6f, 0x6e, 0x29, 0x3a, 0x20, 0x20, 0x42, 0x61, 0x73, 0x65, 0x2d, 0x36, 0x34, 0x20, 0x65,
    0x6e, 0x63, 0x6f, 0x64, 0x65, 0x3f, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x04,
    0x12, 0x04, 0xa4, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x05, 0x12,
    0x04, 0xa4, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x01, 0x12, 0x04,
    0xa4, 0x01, 0x12, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x06, 0x03, 0x12, 0x04, 0xa4,
    0x01, 0x22, 0x23, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x07, 0x12, 0x04, 0xa6, 0x01, 0x02,
    0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x07, 0x04, 0x12, 0x04, 0xa6, 0x01, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x07, 0x06, 0x12, 0x04, 0xa6, 0x01, 0x0b, 0x17, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x07, 0x01, 0x12, 0x04, 0xa6, 0x01, 0x18, 0x1f, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x03, 0x02, 0x07, 0x03, 0x12, 0x04, 0xa6, 0x01, 0x22, 0x23, 0x0a, 0x27, 0x0a,
    0x02, 0x04, 0x04, 0x12, 0x06, 0xaa, 0x01, 0x00, 0xb0, 0x01, 0x01, 0x1a, 0x19, 0x20, 0x44, 0x65,
    0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x75, 0x6d, 0x20,
    0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x04, 0xaa,
    0x01, 0x08, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x04, 0xab, 0x01, 0x02,
    0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, 0x12, 0x04, 0xab, 0x01, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x04, 0xab, 0x01, 0x0b, 0x11, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x04, 0xab, 0x01, 0x12, 0x16, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x04, 0xab, 0x01, 0x19, 0x1a, 0x0a, 0x0c, 0x0a,
    0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x04, 0xad, 0x01, 0x02, 0x2e, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x04, 0x02, 0x01, 0x04, 0x12, 0x04, 0xad, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04,
    0x02, 0x01, 0x06, 0x12, 0x04, 0xad, 0x01, 0x0b, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02,
    0x01, 0x01, 0x12, 0x04, 0xad, 0x01, 0x24, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01,
    0x03, 0x12, 0x04, 0xad, 0x01, 0x2c, 0x2d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, 0x12,
    0x04, 0xaf, 0x01, 0x02, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x04, 0x12, 0x04,
    0xaf, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x06, 0x12, 0x04, 0xaf,
    0x01, 0x0b, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x04, 0xaf, 0x01,
    0x17, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x04, 0xaf, 0x01, 0x21,
    0x22, 0x0a, 0x31, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x06, 0xb3, 0x01, 0x00, 0xb8, 0x01, 0x01, 0x1a,
    0x23, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x61, 0x20, 0x76, 0x61,
    0x6c, 0x75, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e,
    0x75, 0x6d, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x04, 0xb3, 0x01, 0x08,
    0x20, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x04, 0xb4, 0x01, 0x02, 0x1b, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x04, 0x12, 0x04, 0xb4, 0x01, 0x02, 0x0a, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x04, 0xb4, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb4, 0x01, 0x12, 0x16, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb4, 0x01, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x04, 0x04,
    0x05, 0x02, 0x01, 0x12, 0x04, 0xb5, 0x01, 0x02, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02,
    0x01, 0x04, 0x12, 0x04, 0xb5, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01,
    0x05, 0x12, 0x04, 0xb5, 0x01, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01,
    0x12, 0x04, 0xb5, 0x01, 0x11, 0x17, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12,
    0x04, 0xb5, 0x01, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x04, 0xb7,
    0x01, 0x02, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x04, 0x12, 0x04, 0xb7, 0x01,
    0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x06, 0x12, 0x04, 0xb7, 0x01, 0x0b,
    0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x04, 0xb7, 0x01, 0x1c, 0x23,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x04, 0xb7, 0x01, 0x26, 0x27, 0x0a,
    0x24, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x06, 0xbb, 0x01, 0x00, 0xc0, 0x01, 0x01, 0x1a, 0x16, 0x20,
    0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76,
    0x69, 0x63, 0x65, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x04, 0xbb, 0x01,
    0x08, 0x1e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x04, 0xbc, 0x01, 0x02, 0x1b,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, 0x04, 0xbc, 0x01, 0x02, 0x0a, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x04, 0xbc, 0x01, 0x0b, 0x11, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x04, 0xbc, 0x01, 0x12, 0x16, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x04, 0xbc, 0x01, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x04,
    0x04, 0x06, 0x02, 0x01, 0x12, 0x04, 0xbd, 0x01, 0x02, 0x2c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06,
    0x02, 0x01, 0x04, 0x12, 0x04, 0xbd, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02,
    0x01, 0x06, 0x12, 0x04, 0xbd, 0x01, 0x0b, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01,
    0x01, 0x12, 0x04, 0xbd, 0x01, 0x21, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x01, 0x03,
    0x12, 0x04, 0xbd, 0x01, 0x2a, 0x2b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x02, 0x12, 0x04,
    0xbf, 0x01, 0x02, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x04, 0x12, 0x04, 0xbf,
    0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x06, 0x12, 0x04, 0xbf, 0x01,
    0x0b, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x01, 0x12, 0x04, 0xbf, 0x01, 0x1a,
    0x21, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x02, 0x03, 0x12, 0x04, 0xbf, 0x01, 0x24, 0x25,
    0x0a, 0x30, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x06, 0xc3, 0x01, 0x00, 0xcc, 0x01, 0x01, 0x1a, 0x22,
    0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x65, 0x74,
    0x68, 0x6f, 0x64, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
    0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x04, 0xc3, 0x01, 0x08, 0x1d, 0x0a,
    0x0c, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x04, 0xc4, 0x01, 0x02, 0x1b, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x07, 0x02, 0x00, 0x04, 0x12, 0x04, 0xc4, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x07, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc4, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x07, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc4, 0x01, 0x12, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07,
    0x02, 0x00, 0x03, 0x12, 0x04, 0xc4, 0x01, 0x19, 0x1a, 0x0a, 0x97, 0x01, 0x0a, 0x04, 0x04, 0x07,
    0x02, 0x01, 0x12, 0x04, 0xc8, 0x01, 0x02, 0x21, 0x1a, 0x88, 0x01, 0x20, 0x49, 0x6e, 0x70, 0x75,
    0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79, 0x70,
    0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x73, 0x65, 0x20,
    0x61, 0x72, 0x65, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x77, 0x61, 0x79, 0x20, 0x61, 0x73, 0x0a,
    0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
    0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x2c,
    0x20, 0x62, 0x75, 0x74, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x20,
    0x74, 0x6f, 0x20, 0x61, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x74, 0x79, 0x70,
    0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x04, 0x12, 0x04, 0xc8, 0x01,
    0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc8, 0x01, 0x0b,
    0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc8, 0x01, 0x12, 0x1c,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc8, 0x01, 0x1f, 0x20, 0x0a,
    0x0c, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x04, 0xc9, 0x01, 0x02, 0x22, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x07, 0x02, 0x02, 0x04, 0x12, 0x04, 0xc9, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x07, 0x02, 0x02, 0x05, 0x12, 0x04, 0xc9, 0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x07, 0x02, 0x02, 0x01, 0x12, 0x04, 0xc9, 0x01, 0x12, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07,
    0x02, 0x02, 0x03, 0x12, 0x04, 0xc9, 0x01, 0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x07, 0x02,
    0x03, 0x12, 0x04, 0xcb, 0x01, 0x02, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x04,
    0x12, 0x04, 0xcb, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x06, 0x12,
    0x04, 0xcb, 0x01, 0x0b, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x01, 0x12, 0x04,
    0xcb, 0x01, 0x19, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x03, 0x03, 0x12, 0x04, 0xcb,
    0x01, 0x23, 0x24, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x06, 0xf0, 0x01, 0x00, 0xb0, 0x02,
    0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x04, 0xf0, 0x01, 0x08, 0x13, 0x0a, 0xf4,
    0x01, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x04, 0xf6, 0x01, 0x02, 0x23, 0x1a, 0xe5, 0x01,
    0x20, 0x53, 0x65, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4a, 0x61, 0x76, 0x61, 0x20, 0x70,
    0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x63, 0x6c, 0x61,
    0x73, 0x73, 0x65, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66,
    0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20,
    0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x2e,
    0x20, 0x20, 0x42, 0x79, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2c, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20,
    0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x74, 0x68, 0x69,
    0x73, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x0a, 0x20, 0x69, 0x6e, 0x61, 0x70,
    0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73,
    0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73,
    0x20, 0x64, 0x6f, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x6c, 0x79,
    0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x61, 0x63, 0x6b,
    0x77, 0x61, 0x72, 0x64, 0x73, 0x0a, 0x20, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x6e, 0x61,
    0x6d, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x04,
    0xf6, 0x01, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x04, 0xf6,
    0x01, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x04, 0xf6, 0x01,
    0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x04, 0xf6, 0x01, 0x21,
    0x22, 0x0a, 0xbf, 0x02, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x01, 0x12, 0x04, 0xfe, 0x01, 0x02, 0x2b,
    0x1a, 0xb0, 0x02, 0x20, 0x49, 0x66, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x61, 0x6c, 0x6c, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d,
    0x20, 0x74, 0x68, 0x65, 0x20, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, 0x65,
    0x20, 0x61, 0x72, 0x65, 0x20, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20,
    0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x0a, 0x20, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x20,
    0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67,
    0x69, 0x76, 0x65, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x69, 0x73,
    0x20, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x6f, 0x74, 0x68,
    0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x31, 0x0a, 0x20, 0x28, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61,
    0x6c, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6c, 0x64, 0x20,
    0x22, 0x2d, 0x2d, 0x6f, 0x6e, 0x65, 0x5f, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65,
    0x22, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x50, 0x72,
    0x6f, 0x74, 0x6f, 0x32, 0x20, 0x28, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x61, 0x20, 0x2e,
    0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x74, 0x72, 0x61,
    0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e,
    0x67, 0x6c, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x79,
    0x6f, 0x75, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x0a, 0x20,
    0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x6c, 0x79, 0x20, 0x63, 0x68, 0x6f, 0x6f, 0x73,
    0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x6e, 0x61, 0x6d, 0x65,
    0x29, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x04, 0x12, 0x04, 0xfe, 0x01,
    0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, 0x04, 0xfe, 0x01, 0x0b,
    0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x04, 0xfe, 0x01, 0x12, 0x26,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x04, 0xfe, 0x01, 0x29, 0x2a, 0x0a,
    0xa3, 0x03, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x02, 0x12, 0x04, 0x86, 0x02, 0x02, 0x39, 0x1a, 0x94,
    0x03, 0x20, 0x49, 0x66, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x74,
    0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4a, 0x61, 0x76, 0x61, 0x20, 0x63, 0x6f, 0x64,
    0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c,
    0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x61, 0x20, 0x73, 0x65, 0x70, 0x61,
    0x72, 0x61, 0x74, 0x65, 0x20, 0x2e, 0x6a, 0x61, 0x76, 0x61, 0x0a, 0x20, 0x66, 0x69, 0x6c, 0x65,
    0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x74, 0x6f, 0x70, 0x2d, 0x6c, 0x65,
    0x76, 0x65, 0x6c, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x65, 0x6e, 0x75,
    0x6d, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x64,
    0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x2e, 0x70,
    0x72, 0x6f, 0x74, 0x6f, 0x0a, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x75,
    0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x77,
    0x69, 0x6c, 0x6c, 0x20, 0x2a, 0x6e, 0x6f, 0x74, 0x2a, 0x20, 0x62, 0x65, 0x20, 0x6e, 0x65, 0x73,
    0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f,
    0x75, 0x74, 0x65, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x0a, 0x20, 0x6e, 0x61, 0x6d, 0x65,
    0x64, 0x20, 0x62, 0x79, 0x20, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f,
    0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x20, 0x48, 0x6f, 0x77, 0x65,
    0x76, 0x65, 0x72, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x20, 0x63,
    0x6c, 0x61, 0x73, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20,
    0x62, 0x65, 0x0a, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f,
    0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c,
    0x65, 0x27, 0x73, 0x20, 0x67, 0x65, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
    0x72, 0x28, 0x29, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65,
    0x6c, 0x6c, 0x20, 0x61, 0x73, 0x20, 0x61, 0x6e, 0x79, 0x0a, 0x20, 0x74, 0x6f, 0x70, 0x2d, 0x6c,
    0x65, 0x76, 0x65, 0x6c, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20,
    0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66,
    0x69, 0x6c, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x04, 0x12, 0x04,
    0x86, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, 0x12, 0x04, 0x86,
    0x02, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x04, 0x86, 0x02,
    0x10, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x03, 0x12, 0x04, 0x86, 0x02, 0x26,
    0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x08, 0x12, 0x04, 0x86, 0x02, 0x29, 0x38,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x07, 0x12, 0x04, 0x86, 0x02, 0x32, 0x37, 0x0a,
    0x9b, 0x02, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x03, 0x12, 0x04, 0x8c, 0x02, 0x02, 0x43, 0x1a, 0x8c,
    0x02, 0x20, 0x49, 0x66, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x20, 0x74,
    0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4a, 0x61, 0x76, 0x61, 0x20, 0x63, 0x6f, 0x64,
    0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x20, 0x77, 0x69, 0x6c, 0x6c,
    0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x73,
    0x28, 0x29, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x68, 0x61, 0x73, 0x68, 0x43, 0x6f, 0x64, 0x65,
    0x28, 0x29, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61,
    0x6c, 0x6c, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69,
    0x6e, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x2e, 0x70, 0x72, 0x6f, 0x74,
    0x6f, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x0a,
    0x20, 0x70, 0x75, 0x72, 0x65, 0x6c, 0x79, 0x20, 0x61, 0x20, 0x73, 0x70, 0x65, 0x65, 0x64, 0x20,
    0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x61, 0x73,
    0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x62, 0x73, 0x74, 0x72, 0x61, 0x63, 0x74, 0x4d, 0x65, 0x73,
    0x73, 0x61, 0x67, 0x65, 0x20, 0x62, 0x61, 0x73, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20,
    0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x0a, 0x20, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63,
    0x74, 0x69, 0x6f, 0x6e, 0x2d, 0x62, 0x61, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65,
    0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68,
    0x65, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x08, 0x02, 0x03, 0x04, 0x12, 0x04, 0x8c, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x08, 0x02, 0x03, 0x05, 0x12, 0x04, 0x8c, 0x02, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x08, 0x02, 0x03, 0x01, 0x12, 0x04, 0x8c, 0x02, 0x10, 0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08,
    0x02, 0x03, 0x03, 0x12, 0x04, 0x8c, 0x02, 0x30, 0x32, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02,
    0x03, 0x08, 0x12, 0x04, 0x8c, 0x02, 0x33, 0x42, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03,
    0x07, 0x12, 0x04, 0x8c, 0x02, 0x3c, 0x41, 0x0a, 0x4c, 0x0a, 0x04, 0x04, 0x08, 0x04, 0x00, 0x12,
    0x06, 0x8f, 0x02, 0x02, 0x94, 0x02, 0x03, 0x1a, 0x3c, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
    0x74, 0x65, 0x64, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20,
    0x62, 0x65, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72,
    0x20, 0x73, 0x70, 0x65, 0x65, 0x64, 0x20, 0x6f, 0x72, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x73,
    0x69, 0x7a, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x04, 0x00, 0x01, 0x12, 0x04,
    0x8f, 0x02, 0x07, 0x13, 0x0a, 0x44, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04,
    0x90, 0x02, 0x04, 0x0e, 0x22, 0x34, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x20,
    0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f,
    0x72, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, 0x2c, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61,
    0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08,
    0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0x90, 0x02, 0x04, 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04,
    0x08, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0x90, 0x02, 0x0c, 0x0d, 0x0a, 0x47, 0x0a, 0x06,
    0x04, 0x08, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0x92, 0x02, 0x04, 0x12, 0x1a, 0x06, 0x20, 0x65,
    0x74, 0x63, 0x2e, 0x0a, 0x22, 0x2f, 0x20, 0x55, 0x73, 0x65, 0x20, 0x52, 0x65, 0x66, 0x6c, 0x65,
    0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6d, 0x70, 0x6c,
    0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x68,
    0x6f, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x01, 0x01,
    0x12, 0x04, 0x92, 0x02, 0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x01,
    0x02, 0x12, 0x04, 0x92, 0x02, 0x10, 0x11, 0x0a, 0x47, 0x0a, 0x06, 0x04, 0x08, 0x04, 0x00, 0x02,
    0x02, 0x12, 0x04, 0x93, 0x02, 0x04, 0x15, 0x22, 0x37, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
    0x74, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x4d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x6c, 0x69, 0x74, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x0a,
    0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0x93, 0x02, 0x04,
    0x10, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x08, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x04, 0x93, 0x02,
    0x13, 0x14, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x04, 0x12, 0x04, 0x95, 0x02, 0x02, 0x39,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x04, 0x12, 0x04, 0x95, 0x02, 0x02, 0x0a, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x06, 0x12, 0x04, 0x95, 0x02, 0x0b, 0x17, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x08, 0x02, 0x04, 0x01, 0x12, 0x04, 0x95, 0x02, 0x18, 0x24, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x08, 0x02, 0x04, 0x03, 0x12, 0x04, 0x95, 0x02, 0x27, 0x28, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x08, 0x02, 0x04, 0x08, 0x12, 0x04, 0x95, 0x02, 0x29, 0x38, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x08, 0x02, 0x04, 0x07, 0x12, 0x04, 0x95, 0x02, 0x32, 0x37, 0x0a, 0x73, 0x0a, 0x04, 0x04, 0x08,
    0x02, 0x05, 0x12, 0x04, 0x99, 0x02, 0x02, 0x22, 0x1a, 0x65, 0x20, 0x53, 0x65, 0x74, 0x73, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x47, 0x6f, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x77,
    0x68, 0x65, 0x72, 0x65, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x67, 0x65, 0x6e,
    0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x69, 0x73,
    0x20, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x0a,
    0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65, 0x20,
    0x69, 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x2e, 0x0a, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x04, 0x12, 0x04, 0x99, 0x02, 0x02, 0x0a, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x08, 0x02, 0x05, 0x05, 0x12, 0x04, 0x99, 0x02, 0x0b, 0x11, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x08, 0x02, 0x05, 0x01, 0x12, 0x04, 0x99, 0x02, 0x12, 0x1c, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x08, 0x02, 0x05, 0x03, 0x12, 0x04, 0x99, 0x02, 0x1f, 0x21, 0x0a, 0xcb, 0x04, 0x0a, 0x04,
    0x04, 0x08, 0x02, 0x06, 0x12, 0x04, 0xa7, 0x02, 0x02, 0x39, 0x1a, 0xbc, 0x04, 0x20, 0x53, 0x68,
    0x6f, 0x75, 0x6c, 0x64, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72,
    0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x62, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
    0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75,
    0x61, 0x67, 0x65, 0x3f, 0x20, 0x20, 0x22, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x22, 0x20,
    0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x0a, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f,
    0x74, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e,
    0x79, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x52, 0x50, 0x43,
    0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x79, 0x20, 0x61,
    0x72, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20,
    0x74, 0x68, 0x65, 0x0a, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x67,
    0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x61, 0x63,
    0x68, 0x20, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x20, 0x28, 0x77, 0x69, 0x74, 0x68,
    0x6f, 0x75, 0x74, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x70,
    0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x29, 0x2e, 0x0a, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69,
    0x63, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x77, 0x65, 0x72, 0x65, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x6b, 0x69, 0x6e, 0x64, 0x20, 0x6f, 0x66,
    0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
    0x69, 0x6f, 0x6e, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79,
    0x0a, 0x20, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73,
    0x20, 0x6f, 0x66, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x0a, 0x0a, 0x20, 0x47, 0x65,
    0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x20, 0x61,
    0x72, 0x65, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x65,
    0x64, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20,
    0x66, 0x61, 0x76, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x70,
    0x6c, 0x75, 0x67, 0x69, 0x6e, 0x73, 0x0a, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x67, 0x65, 0x6e,
    0x65, 0x72, 0x61, 0x74, 0x65, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69,
    0x66, 0x69, 0x63, 0x20, 0x74, 0x6f, 0x20, 0x79, 0x6f, 0x75, 0x72, 0x20, 0x70, 0x61, 0x72, 0x74,
    0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x52, 0x50, 0x43, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65,
    0x6d, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x2c, 0x0a, 0x20,
    0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x6f,
    0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x2e, 0x20, 0x20, 0x4f, 0x6c, 0x64, 0x20, 0x63, 0x6f, 0x64,
    0x65, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x73, 0x20,
    0x6f, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69,
    0x63, 0x65, 0x73, 0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x0a, 0x20, 0x65, 0x78, 0x70, 0x6c,
    0x69, 0x63, 0x69, 0x74, 0x6c, 0x79, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20,
    0x74, 0x6f, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02,
    0x06, 0x04, 0x12, 0x04, 0xa7, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06,
    0x05, 0x12, 0x04, 0xa7, 0x02, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x01,
    0x12, 0x04, 0xa7, 0x02, 0x10, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x03, 0x12,
    0x04, 0xa7, 0x02, 0x26, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x08, 0x12, 0x04,
    0xa7, 0x02, 0x29, 0x38, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x06, 0x07, 0x12, 0x04, 0xa7,
    0x02, 0x32, 0x37, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x07, 0x12, 0x04, 0xa8, 0x02, 0x02,
    0x3b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x04, 0x12, 0x04, 0xa8, 0x02, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x05, 0x12, 0x04, 0xa8, 0x02, 0x0b, 0x0f, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x01, 0x12, 0x04, 0xa8, 0x02, 0x10, 0x25, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x08, 0x02, 0x07, 0x03, 0x12, 0x04, 0xa8, 0x02, 0x28, 0x2a, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x08, 0x02, 0x07, 0x08, 0x12, 0x04, 0xa8, 0x02, 0x2b, 0x3a, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x08, 0x02, 0x07, 0x07, 0x12, 0x04, 0xa8, 0x02, 0x34, 0x39, 0x0a, 0x0c, 0x0a, 0x04, 0x04,
    0x08, 0x02, 0x08, 0x12, 0x04, 0xa9, 0x02, 0x02, 0x39, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02,
    0x08, 0x04, 0x12, 0x04, 0xa9, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08,
    0x05, 0x12, 0x04, 0xa9, 0x02, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x01,
    0x12, 0x04, 0xa9, 0x02, 0x10, 0x23, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x03, 0x12,
    0x04, 0xa9, 0x02, 0x26, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x08, 0x12, 0x04,
    0xa9, 0x02, 0x29, 0x38, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x08, 0x07, 0x12, 0x04, 0xa9,
    0x02, 0x32, 0x37, 0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x09, 0x12, 0x04, 0xac, 0x02, 0x02,
    0x3a, 0x1a, 0x41, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73,
    0x74, 0x6f, 0x72, 0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74,
    0x20, 0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69,
    0x7a, 0x65, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f,
    0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x04, 0x12, 0x04, 0xac,
    0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x06, 0x12, 0x04, 0xac, 0x02,
    0x0b, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x01, 0x12, 0x04, 0xac, 0x02, 0x1f,
    0x33, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x09, 0x03, 0x12, 0x04, 0xac, 0x02, 0x36, 0x39,
    0x0a, 0x5a, 0x0a, 0x03, 0x04, 0x08, 0x05, 0x12, 0x04, 0xaf, 0x02, 0x02, 0x19, 0x1a, 0x4d, 0x20,
    0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69,
    0x6e, 0x65, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
    0x73, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20,
    0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e,
    0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04,
    0x04, 0x08, 0x05, 0x00, 0x12, 0x04, 0xaf, 0x02, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08,
    0x05, 0x00, 0x01, 0x12, 0x04, 0xaf, 0x02, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x08, 0x05,
    0x00, 0x02, 0x12, 0x04, 0xaf, 0x02, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x06,
    0xb2, 0x02, 0x00, 0xd1, 0x02, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x04, 0xb2,
    0x02, 0x08, 0x16, 0x0a, 0xd8, 0x05, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0xc5, 0x02,
    0x02, 0x3c, 0x1a, 0xc9, 0x05, 0x20, 0x53, 0x65, 0x74, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x74,
    0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x6c, 0x64, 0x20, 0x70, 0x72,
    0x6f, 0x74, 0x6f, 0x31, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x20,
    0x77, 0x69, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20,
    0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69,
    0x73, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x66, 0x6f,
    0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x2d, 0x63, 0x6f, 0x6d, 0x70,
    0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74,
    0x68, 0x65, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x20, 0x77, 0x69,
    0x72, 0x65, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x2e, 0x20, 0x20, 0x59, 0x6f, 0x75,
    0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x6f, 0x74, 0x68,
    0x65, 0x72, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x3a, 0x20, 0x20, 0x49, 0x74, 0x27, 0x73,
    0x20, 0x6c, 0x65, 0x73, 0x73, 0x0a, 0x20, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74,
    0x2c, 0x20, 0x68, 0x61, 0x73, 0x20, 0x66, 0x65, 0x77, 0x65, 0x72, 0x20, 0x66, 0x65, 0x61, 0x74,
    0x75, 0x72, 0x65, 0x73, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x73, 0x20, 0x6d, 0x6f, 0x72,
    0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x6d, 0x75, 0x73,
    0x74, 0x20, 0x62, 0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x65, 0x78, 0x61,
    0x63, 0x74, 0x6c, 0x79, 0x20, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x73, 0x3a,
    0x0a, 0x20, 0x20, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x46, 0x6f, 0x6f, 0x20,
    0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66,
    0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x3b, 0x0a, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x34, 0x20,
    0x74, 0x6f, 0x20, 0x6d, 0x61, 0x78, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x4e, 0x6f,
    0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73,
    0x61, 0x67, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20,
    0x61, 0x6e, 0x79, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c,
    0x64, 0x73, 0x3b, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x73, 0x20,
    0x6f, 0x6e, 0x6c, 0x79, 0x0a, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e,
    0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x20, 0x41, 0x6c, 0x6c, 0x20, 0x65, 0x78, 0x74,
    0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x79, 0x6f, 0x75, 0x72, 0x20,
    0x74, 0x79, 0x70, 0x65, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x73, 0x69, 0x6e,
    0x67, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x3b, 0x20,
    0x65, 0x2e, 0x67, 0x2e, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
    0x0a, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x73, 0x2c, 0x20, 0x65, 0x6e, 0x75,
    0x6d, 0x73, 0x2c, 0x20, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20,
    0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x20, 0x42, 0x65, 0x63, 0x61,
    0x75, 0x73, 0x65, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x6f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65,
    0x20, 0x74, 0x77, 0x6f, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e,
    0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6e, 0x66, 0x6f, 0x72, 0x63,
    0x65, 0x64, 0x20, 0x62, 0x79, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f,
    0x63, 0x6f, 0x6c, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x04, 0x12, 0x04, 0xc5, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x09, 0x02, 0x00, 0x05, 0x12, 0x04, 0xc5, 0x02, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc5, 0x02, 0x10, 0x27, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x09, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc5, 0x02, 0x2a, 0x2b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09,
    0x02, 0x00, 0x08, 0x12, 0x04, 0xc5, 0x02, 0x2c, 0x3b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02,
    0x00, 0x07, 0x12, 0x04, 0xc5, 0x02, 0x35, 0x3a, 0x0a, 0xeb, 0x01, 0x0a, 0x04, 0x04, 0x09, 0x02,
    0x01, 0x12, 0x04, 0xca, 0x02, 0x02, 0x44, 0x1a, 0xdc, 0x01, 0x20, 0x44, 0x69, 0x73, 0x61, 0x62,
    0x6c, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61,
    0x72, 0x64, 0x20, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x28, 0x29,
    0x22, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x63,
    0x68, 0x20, 0x63, 0x61, 0x6e, 0x0a, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x20,
    0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x20,
    0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x74, 0x20, 0x74, 0x6f,
    0x20, 0x6d, 0x61, 0x6b, 0x65, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a,
    0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x31, 0x20, 0x65, 0x61, 0x73,
    0x69, 0x65, 0x72, 0x3b, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x73, 0x68,
    0x6f, 0x75, 0x6c, 0x64, 0x20, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64,
    0x73, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x20, 0x22, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
    0x74, 0x6f, 0x72, 0x22, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x04, 0x12,
    0x04, 0xca, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x05, 0x12, 0x04,
    0xca, 0x02, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x01, 0x12, 0x04, 0xca,
    0x02, 0x10, 0x2f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x03, 0x12, 0x04, 0xca, 0x02,
    0x32, 0x33, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x08, 0x12, 0x04, 0xca, 0x02, 0x34,
    0x43, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x01, 0x07, 0x12, 0x04, 0xca, 0x02, 0x3d, 0x42,
    0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x02, 0x12, 0x04, 0xcd, 0x02, 0x02, 0x3a, 0x1a, 0x41,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72,
    0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6f,
    0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x20,
    0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x04, 0x12, 0x04, 0xcd, 0x02, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x06, 0x12, 0x04, 0xcd, 0x02, 0x0b, 0x1e, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x01, 0x12, 0x04, 0xcd, 0x02, 0x1f, 0x33, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x09, 0x02, 0x02, 0x03, 0x12, 0x04, 0xcd, 0x02, 0x36, 0x39, 0x0a, 0x5a, 0x0a,
    0x03, 0x04, 0x09, 0x05, 0x12, 0x04, 0xd0, 0x02, 0x02, 0x19, 0x1a, 0x4d, 0x20, 0x43, 0x6c, 0x69,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20,
    0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x53, 0x65,
    0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x09, 0x05,
    0x00, 0x12, 0x04, 0xd0, 0x02, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x05, 0x00, 0x01,
    0x12, 0x04, 0xd0, 0x02, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x05, 0x00, 0x02, 0x12,
    0x04, 0xd0, 0x02, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0xd3, 0x02, 0x00,
    0xa3, 0x03, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0xd3, 0x02, 0x08, 0x14,
    0x0a, 0xa3, 0x02, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0xd8, 0x02, 0x02, 0x2e, 0x1a,
    0x94, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x74, 0x79, 0x70, 0x65, 0x20, 0x6f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x73, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72,
    0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, 0x20, 0x64, 0x69,
    0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x0a, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65,
    0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66,
    0x69, 0x65, 0x6c, 0x64, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x69, 0x74, 0x20, 0x6e, 0x6f, 0x72,
    0x6d, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x2e, 0x20, 0x20, 0x53, 0x65,
    0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x0a, 0x20,
    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x2e, 0x20, 0x20,
    0x54, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x6e,
    0x6f, 0x74, 0x20, 0x79, 0x65, 0x74, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
    0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x73,
    0x6f, 0x75, 0x72, 0x63, 0x65, 0x0a, 0x20, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x2d,
    0x2d, 0x20, 0x73, 0x6f, 0x72, 0x72, 0x79, 0x2c, 0x20, 0x77, 0x65, 0x27, 0x6c, 0x6c, 0x20, 0x74,
    0x72, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x69, 0x74,
    0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x20, 0x76, 0x65, 0x72,
    0x73, 0x69, 0x6f, 0x6e, 0x21, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12,
    0x04, 0xd8, 0x02, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04,
    0xd8, 0x02, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd8,
    0x02, 0x11, 0x16, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd8, 0x02,
    0x19, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x08, 0x12, 0x04, 0xd8, 0x02, 0x1b,
    0x2d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x07, 0x12, 0x04, 0xd8, 0x02, 0x26, 0x2c,
    0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0a, 0x04, 0x00, 0x12, 0x06, 0xd9, 0x02, 0x02, 0xe0, 0x02, 0x03,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x04, 0x00, 0x01, 0x12, 0x04, 0xd9, 0x02, 0x07, 0x0c, 0x0a,
    0x1f, 0x0a, 0x06, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x00, 0x12, 0x04, 0xdb, 0x02, 0x04, 0x0f, 0x1a,
    0x0f, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0a,
    0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xdb, 0x02, 0x04,
    0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x04, 0xdb, 0x02,
    0x0d, 0x0e, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x01, 0x12, 0x04, 0xdd, 0x02,
    0x04, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xdd,
    0x02, 0x04, 0x08, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x04,
    0xdd, 0x02, 0x0b, 0x0c, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x02, 0x12, 0x04,
    0xdf, 0x02, 0x04, 0x15, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12,
    0x04, 0xdf, 0x02, 0x04, 0x10, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x04, 0x00, 0x02, 0x02, 0x02,
    0x12, 0x04, 0xdf, 0x02, 0x13, 0x14, 0x0a, 0x8a, 0x02, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x01, 0x12,
    0x04, 0xe5, 0x02, 0x02, 0x1b, 0x1a, 0xfb, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x63,
    0x6b, 0x65, 0x64, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62,
    0x65, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x72, 0x65,
    0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65,
    0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x61, 0x62, 0x6c,
    0x65, 0x0a, 0x20, 0x61, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69,
    0x65, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x20,
    0x52, 0x61, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x72, 0x65, 0x70, 0x65,
    0x61, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x0a, 0x20, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65,
    0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e,
    0x74, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x20, 0x61, 0x72,
    0x72, 0x61, 0x79, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x61,
    0x73, 0x0a, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x6c, 0x65, 0x6e, 0x67,
    0x74, 0x68, 0x2d, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x62, 0x6c, 0x6f,
    0x62, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x04, 0x12, 0x04, 0xe5, 0x02,
    0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x05, 0x12, 0x04, 0xe5, 0x02, 0x0b,
    0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x01, 0x12, 0x04, 0xe5, 0x02, 0x10, 0x16,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x01, 0x03, 0x12, 0x04, 0xe5, 0x02, 0x19, 0x1a, 0x0a,
    0xf0, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x02, 0x12, 0x04, 0x85, 0x03, 0x02, 0x29, 0x1a, 0xe1,
    0x0c, 0x20, 0x53, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69,
    0x65, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, 0x6c, 0x61,
    0x7a, 0x69, 0x6c, 0x79, 0x3f, 0x20, 0x20, 0x4c, 0x61, 0x7a, 0x79, 0x20, 0x61, 0x70, 0x70, 0x6c,
    0x69, 0x65, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x65, 0x73, 0x73,
    0x61, 0x67, 0x65, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73,
    0x2e, 0x20, 0x20, 0x49, 0x74, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74,
    0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x20,
    0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69,
    0x61, 0x6c, 0x6c, 0x79, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x65,
    0x0a, 0x20, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x27,
    0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20,
    0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, 0x62, 0x75,
    0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64,
    0x20, 0x69, 0x6e, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x0a, 0x20, 0x66, 0x6f, 0x72,
    0x6d, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x6d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x61, 0x63, 0x74, 0x75, 0x61,
    0x6c, 0x6c, 0x79, 0x20, 0x62, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, 0x77, 0x68,
    0x65, 0x6e, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x61,
    0x63, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20,
    0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x61, 0x20, 0x68, 0x69, 0x6e, 0x74, 0x2e, 0x20,
    0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
    0x20, 0x61, 0x72, 0x65, 0x20, 0x66, 0x72, 0x65, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x68, 0x6f,
    0x6f, 0x73, 0x65, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x75,
    0x73, 0x65, 0x0a, 0x20, 0x65, 0x61, 0x67, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x61, 0x7a,
    0x79, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64,
    0x6c, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75,
    0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
    0x2e, 0x20, 0x20, 0x48, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x2c, 0x0a, 0x20, 0x73, 0x65, 0x74,
    0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
    0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x73, 0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x73, 0x20, 0x74,
    0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
    0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x20, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x76, 0x65, 0x73,
    0x20, 0x74, 0x68, 0x61, 0x74, 0x0a, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x61, 0x7a,
    0x79, 0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x69,
    0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x73, 0x20, 0x77, 0x6f, 0x72, 0x74, 0x68,
    0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20,
    0x62, 0x6f, 0x6f, 0x6b, 0x6b, 0x65, 0x65, 0x70, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6f, 0x76, 0x65,
    0x72, 0x68, 0x65, 0x61, 0x64, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20,
    0x6e, 0x65, 0x65, 0x64, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d,
    0x65, 0x6e, 0x74, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61,
    0x66, 0x66, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
    0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e,
    0x79, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x64, 0x65,
    0x3b, 0x0a, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x73, 0x69,
    0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x20, 0x46, 0x75, 0x72, 0x74, 0x68,
    0x65, 0x72, 0x6d, 0x6f, 0x72, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2d, 0x73,
    0x61, 0x66, 0x65, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x69, 0x6e,
    0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x61,
    0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20,
    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x6d, 0x65,
    0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x20, 0x73, 0x61, 0x66,
    0x65, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20,
    0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73,
    0x20, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x2c, 0x20, 0x77,
    0x68, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x6f, 0x6e, 0x2d, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x6d,
    0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x0a,
    0x20, 0x74, 0x6f, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x65, 0x78, 0x63, 0x6c,
    0x75, 0x73, 0x69, 0x76, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x2e, 0x0a, 0x0a, 0x0a,
    0x20, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65,
    0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x63,
    0x68, 0x6f, 0x6f, 0x73, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x68, 0x65,
    0x63, 0x6b, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c,
    0x64, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x0a, 0x20, 0x61, 0x20, 0x6c, 0x61, 0x7a,
    0x79, 0x20, 0x73, 0x75, 0x62, 0x2d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x20,
    0x54, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x2c, 0x20, 0x63, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x67,
    0x20, 0x49, 0x73, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x28, 0x29,
    0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6d,
    0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x0a, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x72, 0x65, 0x74, 0x75,
    0x72, 0x6e, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x69, 0x66, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
    0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65,
    0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, 0x0a, 0x20,
    0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72,
    0x79, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77,
    0x69, 0x73, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x6d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x76, 0x65,
    0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x0a, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64, 0x20, 0x69,
    0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x65, 0x72, 0x66, 0x6f,
    0x72, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x2c, 0x20, 0x64, 0x65,
    0x66, 0x65, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x75, 0x72, 0x70,
    0x6f, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x61, 0x7a, 0x79, 0x0a, 0x20, 0x70, 0x61, 0x72,
    0x73, 0x69, 0x6e, 0x67, 0x2e, 0x20, 0x20, 0x41, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d,
    0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x63,
    0x68, 0x6f, 0x6f, 0x73, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x68,
    0x65, 0x63, 0x6b, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65,
    0x6c, 0x64, 0x73, 0x0a, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e,
    0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x69, 0x74,
    0x2e, 0x20, 0x20, 0x54, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x2c, 0x20, 0x66, 0x6f, 0x72, 0x20,
    0x61, 0x6e, 0x79, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x73,
    0x75, 0x62, 0x2d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x0a,
    0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
    0x6d, 0x75, 0x73, 0x74, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x2a, 0x61, 0x6c, 0x77,
    0x61, 0x79, 0x73, 0x2a, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x20, 0x69, 0x74, 0x73, 0x20, 0x72,
    0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x2c, 0x20,
    0x6f, 0x72, 0x20, 0x2a, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x2a, 0x0a, 0x20, 0x63, 0x68, 0x65, 0x63,
    0x6b, 0x20, 0x69, 0x74, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x66,
    0x69, 0x65, 0x6c, 0x64, 0x73, 0x2c, 0x20, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x6c, 0x65, 0x73,
    0x73, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x68, 0x65, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20,
    0x6e, 0x6f, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20,
    0x68, 0x61, 0x73, 0x0a, 0x20, 0x62, 0x65, 0x65, 0x6e, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x64,
    0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x04, 0x12, 0x04, 0x85, 0x03, 0x02,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x05, 0x12, 0x04, 0x85, 0x03, 0x0b, 0x0f,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x01, 0x12, 0x04, 0x85, 0x03, 0x10, 0x14, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x03, 0x12, 0x04, 0x85, 0x03, 0x17, 0x18, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0a, 0x02, 0x02, 0x08, 0x12, 0x04, 0x85, 0x03, 0x19, 0x28, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x0a, 0x02, 0x02, 0x07, 0x12, 0x04, 0x85, 0x03, 0x22, 0x27, 0x0a, 0xe8, 0x01, 0x0a,
    0x04, 0x04, 0x0a, 0x02, 0x03, 0x12, 0x04, 0x8b, 0x03, 0x02, 0x2f, 0x1a, 0xd9, 0x01, 0x20, 0x49,
    0x73, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x64, 0x65, 0x70,
    0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x3f, 0x0a, 0x20, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64,
    0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65,
    0x74, 0x20, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73,
    0x20, 0x63, 0x61, 0x6e, 0x20, 0x65, 0x6d, 0x69, 0x74, 0x20, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63,
    0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
    0x0a, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x73, 0x2c,
    0x20, 0x6f, 0x72, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x63,
    0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x6c, 0x79, 0x20, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65,
    0x64, 0x3b, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x6c,
    0x65, 0x61, 0x73, 0x74, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x69, 0x73, 0x20, 0x61,
    0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66,
    0x6f, 0x72, 0x20, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66,
    0x69, 0x65, 0x6c, 0x64, 0x73, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x04,
    0x12, 0x04, 0x8b, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x05, 0x12,
    0x04, 0x8b, 0x03, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x04,
    0x8b, 0x03, 0x10, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x04, 0x8b,
    0x03, 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x08, 0x12, 0x04, 0x8b, 0x03,
    0x1f, 0x2e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x03, 0x07, 0x12, 0x04, 0x8b, 0x03, 0x28,
    0x2d, 0x0a, 0xd7, 0x03, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x04, 0x12, 0x04, 0x99, 0x03, 0x02, 0x2b,
    0x1a, 0xc8, 0x03, 0x20, 0x45, 0x58, 0x50, 0x45, 0x52, 0x49, 0x4d, 0x45, 0x4e, 0x54, 0x41, 0x4c,
    0x2e, 0x20, 0x20, 0x44, 0x4f, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x55, 0x53, 0x45, 0x2e, 0x0a, 0x20,
    0x46, 0x6f, 0x72, 0x20, 0x22, 0x6d, 0x61, 0x70, 0x22, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73,
    0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65,
    0x6e, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x61,
    0x74, 0x0a, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x66, 0x6f,
    0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x61, 0x70, 0x2e, 0x20, 0x20, 0x46, 0x6f, 0x72,
    0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x73,
    0x65, 0x20, 0x77, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x6d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x49, 0x74, 0x65, 0x6d, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e,
    0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
    0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x3d, 0x20, 0x32, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x7d,
    0x0a, 0x20, 0x20, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x66,
    0x69, 0x67, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
    0x65, 0x64, 0x20, 0x49, 0x74, 0x65, 0x6d, 0x20, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x3d, 0x20,
    0x31, 0x20, 0x5b, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x5f,
    0x6d, 0x61, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x3d, 0x22, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x5d, 0x3b,
    0x0a, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20, 0x49, 0x6e, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73,
    0x69, 0x74, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61,
    0x70, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x49, 0x74, 0x65, 0x6d, 0x20, 0x77,
    0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x22, 0x6e,
    0x61, 0x6d, 0x65, 0x22, 0x2e, 0x0a, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x3a, 0x20, 0x46, 0x75, 0x6c,
    0x6c, 0x79, 0x2d, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x69,
    0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x74,
    0x68, 0x65, 0x20, 0x22, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c,
    0x5f, 0x22, 0x20, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x99, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a,
    0x02, 0x04, 0x05, 0x12, 0x04, 0x99, 0x03, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02,
    0x04, 0x01, 0x12, 0x04, 0x99, 0x03, 0x12, 0x26, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x04,
    0x03, 0x12, 0x04, 0x99, 0x03, 0x29, 0x2a, 0x0a, 0x3f, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x05, 0x12,
    0x04, 0x9c, 0x03, 0x02, 0x2a, 0x1a, 0x31, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x47, 0x6f, 0x6f, 0x67,
    0x6c, 0x65, 0x2d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x69, 0x67, 0x72,
    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x2e, 0x20, 0x44, 0x6f, 0x20, 0x6e,
    0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05,
    0x04, 0x12, 0x04, 0x9c, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x05,
    0x12, 0x04, 0x9c, 0x03, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x01, 0x12,
    0x04, 0x9c, 0x03, 0x10, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x03, 0x12, 0x04,
    0x9c, 0x03, 0x17, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x08, 0x12, 0x04, 0x9c,
    0x03, 0x1a, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x05, 0x07, 0x12, 0x04, 0x9c, 0x03,
    0x23, 0x28, 0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x06, 0x12, 0x04, 0x9f, 0x03, 0x02, 0x3a,
    0x1a, 0x41, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74,
    0x6f, 0x72, 0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20,
    0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a,
    0x65, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76,
    0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x04, 0x12, 0x04, 0x9f, 0x03,
    0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x06, 0x12, 0x04, 0x9f, 0x03, 0x0b,
    0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x01, 0x12, 0x04, 0x9f, 0x03, 0x1f, 0x33,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x06, 0x03, 0x12, 0x04, 0x9f, 0x03, 0x36, 0x39, 0x0a,
    0x5a, 0x0a, 0x03, 0x04, 0x0a, 0x05, 0x12, 0x04, 0xa2, 0x03, 0x02, 0x19, 0x1a, 0x4d, 0x20, 0x43,
    0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e,
    0x65, 0x20, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
    0x20, 0x69, 0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f,
    0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20,
    0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04, 0x04,
    0x0a, 0x05, 0x00, 0x12, 0x04, 0xa2, 0x03, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x05,
    0x00, 0x01, 0x12, 0x04, 0xa2, 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x05, 0x00,
    0x02, 0x12, 0x04, 0xa2, 0x03, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0xa5,
    0x03, 0x00, 0xb0, 0x03, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0xa5, 0x03,
    0x08, 0x13, 0x0a, 0x62, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0xa9, 0x03, 0x02, 0x2f,
    0x1a, 0x54, 0x20, 0x53, 0x65, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69,
    0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x64,
    0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x20,
    0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x61, 0x67, 0x20, 0x6e, 0x61,
    0x6d, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x0a, 0x20, 0x76,
    0x61, 0x6c, 0x75, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12,
    0x04, 0xa9, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04,
    0xa9, 0x03, 0x0b, 0x0f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa9,
    0x03, 0x10, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa9, 0x03,
    0x1e, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x08, 0x12, 0x04, 0xa9, 0x03, 0x20,
    0x2e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x07, 0x12, 0x04, 0xa9, 0x03, 0x29, 0x2d,
    0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x01, 0x12, 0x04, 0xac, 0x03, 0x02, 0x3a, 0x1a, 0x41,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72,
    0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6f,
    0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x20,
    0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x04, 0x12, 0x04, 0xac, 0x03, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x06, 0x12, 0x04, 0xac, 0x03, 0x0b, 0x1e, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x01, 0x12, 0x04, 0xac, 0x03, 0x1f, 0x33, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0b, 0x02, 0x01, 0x03, 0x12, 0x04, 0xac, 0x03, 0x36, 0x39, 0x0a, 0x5a, 0x0a,
    0x03, 0x04, 0x0b, 0x05, 0x12, 0x04, 0xaf, 0x03, 0x02, 0x19, 0x1a, 0x4d, 0x20, 0x43, 0x6c, 0x69,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20,
    0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x53, 0x65,
    0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0b, 0x05,
    0x00, 0x12, 0x04, 0xaf, 0x03, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x05, 0x00, 0x01,
    0x12, 0x04, 0xaf, 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x05, 0x00, 0x02, 0x12,
    0x04, 0xaf, 0x03, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xb2, 0x03, 0x00,
    0xb8, 0x03, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, 0x04, 0xb2, 0x03, 0x08, 0x18,
    0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xb4, 0x03, 0x02, 0x3a, 0x1a, 0x41,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72,
    0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6f,
    0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x20,
    0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x04, 0x12, 0x04, 0xb4, 0x03, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb4, 0x03, 0x0b, 0x1e, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb4, 0x03, 0x1f, 0x33, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb4, 0x03, 0x36, 0x39, 0x0a, 0x5a, 0x0a,
    0x03, 0x04, 0x0c, 0x05, 0x12, 0x04, 0xb7, 0x03, 0x02, 0x19, 0x1a, 0x4d, 0x20, 0x43, 0x6c, 0x69,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20,
    0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x53, 0x65,
    0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x05,
    0x00, 0x12, 0x04, 0xb7, 0x03, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x05, 0x00, 0x01,
    0x12, 0x04, 0xb7, 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x05, 0x00, 0x02, 0x12,
    0x04, 0xb7, 0x03, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0xba, 0x03, 0x00,
    0xc6, 0x03, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, 0x12, 0x04, 0xba, 0x03, 0x08, 0x16,
    0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0xc2, 0x03, 0x02, 0x3a, 0x1a, 0x41,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72,
    0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6f,
    0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x20,
    0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x04, 0x12, 0x04, 0xc2, 0x03, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0xc2, 0x03, 0x0b, 0x1e, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0xc2, 0x03, 0x1f, 0x33, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0xc2, 0x03, 0x36, 0x39, 0x0a, 0x5a, 0x0a,
    0x03, 0x04, 0x0d, 0x05, 0x12, 0x04, 0xc5, 0x03, 0x02, 0x19, 0x1a, 0x4d, 0x20, 0x43, 0x6c, 0x69,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20,
    0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x53, 0x65,
    0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x05,
    0x00, 0x12, 0x04, 0xc5, 0x03, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x05, 0x00, 0x01,
    0x12, 0x04, 0xc5, 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x05, 0x00, 0x02, 0x12,
    0x04, 0xc5, 0x03, 0x15, 0x18, 0x0a, 0x0c, 0x0a, 0x02, 0x04, 0x0e, 0x12, 0x06, 0xc8, 0x03, 0x00,
    0xd4, 0x03, 0x01, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0e, 0x01, 0x12, 0x04, 0xc8, 0x03, 0x08, 0x15,
    0x0a, 0x4f, 0x0a, 0x04, 0x04, 0x0e, 0x02, 0x00, 0x12, 0x04, 0xd0, 0x03, 0x02, 0x3a, 0x1a, 0x41,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72,
    0x65, 0x73, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6f,
    0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x20,
    0x68, 0x65, 0x72, 0x65, 0x2e, 0x20, 0x53, 0x65, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x04, 0x12, 0x04, 0xd0, 0x03, 0x02, 0x0a,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x06, 0x12, 0x04, 0xd0, 0x03, 0x0b, 0x1e, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x01, 0x12, 0x04, 0xd0, 0x03, 0x1f, 0x33, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0e, 0x02, 0x00, 0x03, 0x12, 0x04, 0xd0, 0x03, 0x36, 0x39, 0x0a, 0x5a, 0x0a,
    0x03, 0x04, 0x0e, 0x05, 0x12, 0x04, 0xd3, 0x03, 0x02, 0x19, 0x1a, 0x4d, 0x20, 0x43, 0x6c, 0x69,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20,
    0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x20, 0x53, 0x65,
    0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0e, 0x05,
    0x00, 0x12, 0x04, 0xd3, 0x03, 0x0d, 0x18, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x05, 0x00, 0x01,
    0x12, 0x04, 0xd3, 0x03, 0x0d, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0e, 0x05, 0x00, 0x02, 0x12,
    0x04, 0xd3, 0x03, 0x15, 0x18, 0x0a, 0x8b, 0x03, 0x0a, 0x02, 0x04, 0x0f, 0x12, 0x06, 0xdd, 0x03,
    0x00, 0xf1, 0x03, 0x01, 0x1a, 0xfc, 0x02, 0x20, 0x41, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
    0x65, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61,
    0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72, 0x73,
    0x65, 0x72, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f,
    0x67, 0x6e, 0x69, 0x7a, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x6f, 0x6e, 0x6c, 0x79,
    0x0a, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61,
    0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x69,
    0x6c, 0x65, 0x72, 0x3a, 0x3a, 0x50, 0x61, 0x72, 0x73, 0x65, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73,
    0x73, 0x2e, 0x0a, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x6f,
    0x6f, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x73,
    0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x20,
    0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63,
    0x74, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x2c, 0x0a, 0x20,
    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x20, 0x6f, 0x62, 0x6a,
    0x65, 0x63, 0x74, 0x73, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
    0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
    0x72, 0x3a, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x28, 0x29, 0x2c, 0x0a, 0x20, 0x6f,
    0x72, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x44, 0x65,
    0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3a, 0x3a, 0x43, 0x6f, 0x70, 0x79, 0x54, 0x6f,
    0x28, 0x29, 0x29, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x20, 0x68,
    0x61, 0x76, 0x65, 0x20, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65,
    0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65,
    0x6d, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0f, 0x01, 0x12, 0x04, 0xdd, 0x03, 0x08, 0x1b,
    0x0a, 0xcb, 0x02, 0x0a, 0x04, 0x04, 0x0f, 0x03, 0x00, 0x12, 0x06, 0xe3, 0x03, 0x02, 0xe6, 0x03,
    0x03, 0x1a, 0xba, 0x02, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x6f, 0x66,
    0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
    0x65, 0x64, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x20, 0x45, 0x61, 0x63, 0x68,
    0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e,
    0x74, 0x73, 0x20, 0x61, 0x20, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x0a,
    0x20, 0x61, 0x20, 0x64, 0x6f, 0x74, 0x2d, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x64,
    0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x20, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e,
    0x73, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x74, 0x72, 0x75, 0x65, 0x20, 0x69, 0x66, 0x66,
    0x20, 0x61, 0x20, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65,
    0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x0a, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
    0x69, 0x6f, 0x6e, 0x20, 0x28, 0x64, 0x65, 0x6e, 0x6f, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74,
    0x68, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x68, 0x65, 0x73, 0x65, 0x73, 0x20, 0x69, 0x6e,
    0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x73, 0x70, 0x65, 0x63, 0x73, 0x20, 0x69,
    0x6e, 0x20, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x29, 0x2e,
    0x0a, 0x20, 0x45, 0x2e, 0x67, 0x2e, 0x2c, 0x7b, 0x20, 0x5b, 0x22, 0x66, 0x6f, 0x6f, 0x22, 0x2c,
    0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x5d, 0x2c, 0x20, 0x5b, 0x22, 0x62, 0x61, 0x72, 0x2e, 0x62,
    0x61, 0x7a, 0x22, 0x2c, 0x20, 0x74, 0x72, 0x75, 0x65, 0x5d, 0x2c, 0x20, 0x5b, 0x22, 0x71, 0x75,
    0x78, 0x22, 0x2c, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x5d, 0x20, 0x7d, 0x20, 0x72, 0x65, 0x70,
    0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x0a, 0x20, 0x22, 0x66, 0x6f, 0x6f, 0x2e, 0x28, 0x62,
    0x61, 0x72, 0x2e, 0x62, 0x61, 0x7a, 0x29, 0x2e, 0x71, 0x75, 0x78, 0x22, 0x2e, 0x0a, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0f, 0x03, 0x00, 0x01, 0x12, 0x04, 0xe3, 0x03, 0x0a, 0x12, 0x0a, 0x0e, 0x0a,
    0x06, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04, 0xe4, 0x03, 0x04, 0x22, 0x0a, 0x0f, 0x0a,
    0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x00, 0x04, 0x12, 0x04, 0xe4, 0x03, 0x04, 0x0c, 0x0a, 0x0f,
    0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x04, 0xe4, 0x03, 0x0d, 0x13, 0x0a,
    0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe4, 0x03, 0x14, 0x1d,
    0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe4, 0x03, 0x20,
    0x21, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x01, 0x12, 0x04, 0xe5, 0x03, 0x04,
    0x23, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x01, 0x04, 0x12, 0x04, 0xe5, 0x03,
    0x04, 0x0c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x04, 0xe5,
    0x03, 0x0d, 0x11, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04,
    0xe5, 0x03, 0x12, 0x1e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0f, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12,
    0x04, 0xe5, 0x03, 0x21, 0x22, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x00, 0x12, 0x04, 0xe7,
    0x03, 0x02, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x04, 0x12, 0x04, 0xe7, 0x03,
    0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x06, 0x12, 0x04, 0xe7, 0x03, 0x0b,
    0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x01, 0x12, 0x04, 0xe7, 0x03, 0x14, 0x18,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x00, 0x03, 0x12, 0x04, 0xe7, 0x03, 0x1b, 0x1c, 0x0a,
    0x9c, 0x01, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x01, 0x12, 0x04, 0xeb, 0x03, 0x02, 0x27, 0x1a, 0x8d,
    0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74,
    0x68, 0x65, 0x20, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
    0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, 0x6e, 0x20, 0x77, 0x68, 0x61, 0x74,
    0x65, 0x76, 0x65, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f,
    0x6b, 0x65, 0x6e, 0x69, 0x7a, 0x65, 0x72, 0x0a, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66,
    0x69, 0x65, 0x64, 0x20, 0x69, 0x74, 0x20, 0x61, 0x73, 0x20, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67,
    0x20, 0x70, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, 0x2e, 0x20, 0x45, 0x78, 0x61, 0x63, 0x74, 0x6c,
    0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x73,
    0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0f, 0x02, 0x01, 0x04, 0x12, 0x04, 0xeb, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x0f, 0x02, 0x01, 0x05, 0x12, 0x04, 0xeb, 0x03, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x0f, 0x02, 0x01, 0x01, 0x12, 0x04, 0xeb, 0x03, 0x12, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x0f, 0x02, 0x01, 0x03, 0x12, 0x04, 0xeb, 0x03, 0x25, 0x26, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f,
    0x02, 0x02, 0x12, 0x04, 0xec, 0x03, 0x02, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02,
    0x04, 0x12, 0x04, 0xec, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x05,
    0x12, 0x04, 0xec, 0x03, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x01, 0x12,
    0x04, 0xec, 0x03, 0x12, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x02, 0x03, 0x12, 0x04,
    0xec, 0x03, 0x27, 0x28, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x03, 0x12, 0x04, 0xed, 0x03,
    0x02, 0x28, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x04, 0x12, 0x04, 0xed, 0x03, 0x02,
    0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x05, 0x12, 0x04, 0xed, 0x03, 0x0b, 0x10,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x01, 0x12, 0x04, 0xed, 0x03, 0x11, 0x23, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x03, 0x03, 0x12, 0x04, 0xed, 0x03, 0x26, 0x27, 0x0a, 0x0c,
    0x0a, 0x04, 0x04, 0x0f, 0x02, 0x04, 0x12, 0x04, 0xee, 0x03, 0x02, 0x23, 0x0a, 0x0d, 0x0a, 0x05,
    0x04, 0x0f, 0x02, 0x04, 0x04, 0x12, 0x04, 0xee, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04,
    0x0f, 0x02, 0x04, 0x05, 0x12, 0x04, 0xee, 0x03, 0x0b, 0x11, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f,
    0x02, 0x04, 0x01, 0x12, 0x04, 0xee, 0x03, 0x12, 0x1e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02,
    0x04, 0x03, 0x12, 0x04, 0xee, 0x03, 0x21, 0x22, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x05,
    0x12, 0x04, 0xef, 0x03, 0x02, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x04, 0x12,
    0x04, 0xef, 0x03, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x05, 0x12, 0x04,
    0xef, 0x03, 0x0b, 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x01, 0x12, 0x04, 0xef,
    0x03, 0x11, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x05, 0x03, 0x12, 0x04, 0xef, 0x03,
    0x20, 0x21, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0f, 0x02, 0x06, 0x12, 0x04, 0xf0, 0x03, 0x02, 0x26,
    0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x04, 0x12, 0x04, 0xf0, 0x03, 0x02, 0x0a, 0x0a,
    0x0d, 0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x05, 0x12, 0x04, 0xf0, 0x03, 0x0b, 0x11, 0x0a, 0x0d,
    0x0a, 0x05, 0x04, 0x0f, 0x02, 0x06, 0x01, 0x12, 0x04, 0xf0, 0x03, 0x12, 0x21, 0x0a, 0x0d, 0x0a,
    0x05, 0x04, 0x0f, 0x02, 0x06, 0x03, 0x12, 0x04, 0xf0, 0x03, 0x24, 0x25, 0x0a, 0x78, 0x0a, 0x02,
    0x04, 0x10, 0x12, 0x06, 0xf8, 0x03, 0x00, 0xeb, 0x04, 0x01, 0x1a, 0x6a, 0x20, 0x45, 0x6e, 0x63,
    0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d,
    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20,
    0x66, 0x69, 0x6c, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20,
    0x61, 0x0a, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
    0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x77, 0x61, 0x73, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72,
    0x61, 0x74, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x10, 0x01, 0x12, 0x04, 0xf8,
    0x03, 0x08, 0x16, 0x0a, 0x82, 0x11, 0x0a, 0x04, 0x04, 0x10, 0x02, 0x00, 0x12, 0x04, 0xa4, 0x04,
    0x02, 0x21, 0x1a, 0xf3, 0x10, 0x20, 0x41, 0x20, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
    0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x61, 0x20, 0x70, 0x69,
    0x65, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x63, 0x6f,
    0x64, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66,
    0x69, 0x6c, 0x65, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x0a, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65,
    0x73, 0x70, 0x6f, 0x6e, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x70, 0x61, 0x72, 0x74,
    0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f,
    0x6e, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61,
    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64,
    0x0a, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c, 0x20, 0x74,
    0x6f, 0x20, 0x49, 0x44, 0x45, 0x73, 0x2c, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x69, 0x6e, 0x64,
    0x65, 0x78, 0x65, 0x72, 0x73, 0x2c, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61,
    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2c,
    0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x0a, 0x20, 0x74, 0x6f,
    0x6f, 0x6c, 0x73, 0x2e, 0x0a, 0x0a, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70,
    0x6c, 0x65, 0x2c, 0x20, 0x73, 0x61, 0x79, 0x20, 0x77, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20,
    0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x3a, 0x0a, 0x20, 0x20, 0x20,
    0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x46, 0x6f, 0x6f, 0x20, 0x7b, 0x0a, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x72, 0x69,
    0x6e, 0x67, 0x20, 0x66, 0x6f, 0x6f, 0x20, 0x3d, 0x20, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x7d,
    0x0a, 0x20, 0x4c, 0x65, 0x74, 0x27, 0x73, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x20, 0x61, 0x74, 0x20,
    0x6a, 0x75, 0x73, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x64,
    0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x6f, 0x70,
    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x6f,
    0x6f, 0x20, 0x3d, 0x20, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x5e, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x5e, 0x5e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x5e, 0x5e, 0x20, 0x20, 0x5e, 0x20, 0x20,
    0x5e, 0x5e, 0x5e, 0x0a, 0x20, 0x20, 0x20, 0x61, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x62,
    0x63, 0x20, 0x20, 0x20, 0x20, 0x20, 0x64, 0x65, 0x20, 0x20, 0x66, 0x20, 0x20, 0x67, 0x68, 0x69,
    0x0a, 0x20, 0x57, 0x65, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f,
    0x6c, 0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
    0x73, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x20, 0x20, 0x70, 0x61, 0x74,
    0x68, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x61,
    0x2c, 0x69, 0x29, 0x20, 0x20, 0x5b, 0x20, 0x34, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x32, 0x2c, 0x20,
    0x30, 0x20, 0x5d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x77, 0x68, 0x6f, 0x6c,
    0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69,
    0x6f, 0x6e, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x61, 0x2c, 0x62, 0x29, 0x20, 0x20, 0x5b, 0x20,
    0x34, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x32, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x34, 0x20, 0x5d, 0x20,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x20, 0x28, 0x6f, 0x70, 0x74, 0x69,
    0x6f, 0x6e, 0x61, 0x6c, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x63, 0x2c, 0x64, 0x29, 0x20,
    0x20, 0x5b, 0x20, 0x34, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x32, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x35,
    0x20, 0x5d, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x28, 0x73, 0x74,
    0x72, 0x69, 0x6e, 0x67, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x65, 0x2c, 0x66, 0x29, 0x20,
    0x20, 0x5b, 0x20, 0x34, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x32, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x31,
    0x20, 0x5d, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x28, 0x66, 0x6f,
    0x6f, 0x29, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x67, 0x2c, 0x68, 0x29, 0x20, 0x20, 0x5b, 0x20,
    0x34, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x32, 0x2c, 0x20, 0x30, 0x2c, 0x20, 0x33, 0x20, 0x5d, 0x20,
    0x20, 0x54, 0x68, 0x65, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x28, 0x31, 0x29, 0x2e,
    0x0a, 0x0a, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x73, 0x3a, 0x0a, 0x20, 0x2d, 0x20, 0x41, 0x20, 0x6c,
    0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x72, 0x65, 0x66, 0x65,
    0x72, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20,
    0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x20, 0x28, 0x69, 0x2e,
    0x65, 0x2e, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x6e, 0x79, 0x0a, 0x20, 0x20,
    0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x20, 0x69, 0x6e, 0x64, 0x65,
    0x78, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x20, 0x69, 0x74, 0x29, 0x2e, 0x20, 0x20, 0x54,
    0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x77, 0x68, 0x65, 0x6e,
    0x65, 0x76, 0x65, 0x72, 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x6c,
    0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x72, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x6c, 0x6f,
    0x67, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x65, 0x6e, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64,
    0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x64,
    0x65, 0x20, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x20, 0x20, 0x46, 0x6f, 0x72, 0x20,
    0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x6e, 0x74, 0x69,
    0x72, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x20, 0x62, 0x6c, 0x6f,
    0x63, 0x6b, 0x20, 0x28, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x79, 0x20, 0x63, 0x6f, 0x6e,
    0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65,
    0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e,
    0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x29, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x0a, 0x20, 0x20, 0x20,
    0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x20, 0x6c, 0x6f,
    0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x68, 0x6f, 0x73, 0x65, 0x20, 0x70, 0x61, 0x74,
    0x68, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x22, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x20, 0x72, 0x65, 0x70,
    0x65, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x77,
    0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e,
    0x0a, 0x20, 0x2d, 0x20, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, 0x6c, 0x6f, 0x63,
    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x2e, 0x20, 0x20,
    0x54, 0x68, 0x69, 0x73, 0x20, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x73, 0x20, 0x77, 0x68, 0x65,
    0x6e, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x6c, 0x6f,
    0x67, 0x69, 0x63, 0x61, 0x6c, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f,
    0x6e, 0x20, 0x69, 0x73, 0x20, 0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x75, 0x74, 0x20,
    0x61, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20,
    0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x73,
    0x74, 0x0a, 0x20, 0x20, 0x20, 0x6f, 0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x65, 0x78, 0x61,
    0x6d, 0x70, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x22, 0x65, 0x78, 0x74,
    0x65, 0x6e, 0x64, 0x22, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e,
    0x20, 0x2d, 0x2d, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65,
    0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x65, 0x78, 0x74,
    0x65, 0x6e, 0x64, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2c, 0x20, 0x65, 0x61,
    0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6c, 0x6c,
    0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x70,
    0x61, 0x74, 0x68, 0x2e, 0x0a, 0x20, 0x2d, 0x20, 0x41, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x27, 0x73, 0x20, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x74,
    0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x61, 0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74,
    0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x27, 0x73,
    0x20, 0x73, 0x70, 0x61, 0x6e, 0x2e, 0x20, 0x20, 0x46, 0x6f, 0x72, 0x0a, 0x20, 0x20, 0x20, 0x65,
    0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x22, 0x65, 0x78, 0x74,
    0x65, 0x6e, 0x64, 0x65, 0x65, 0x22, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x65, 0x78, 0x74,
    0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x73, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68,
    0x65, 0x0a, 0x20, 0x20, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f,
    0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x22, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x22, 0x20, 0x62,
    0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x69, 0x73, 0x20, 0x73, 0x68, 0x61, 0x72,
    0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
    0x69, 0x6f, 0x6e, 0x73, 0x20, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x74,
    0x68, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x0a, 0x20, 0x2d, 0x20, 0x4a, 0x75, 0x73,
    0x74, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x61, 0x20, 0x6c, 0x6f, 0x63, 0x61,
    0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73, 0x20, 0x73, 0x70, 0x61, 0x6e, 0x20, 0x69, 0x73, 0x20, 0x61,
    0x20, 0x73, 0x75, 0x62, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20,
    0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x27, 0x73,
    0x20, 0x73, 0x70, 0x61, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f,
    0x74, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x20, 0x69,
    0x73, 0x20, 0x61, 0x20, 0x64, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x20,
    0x20, 0x46, 0x6f, 0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x61, 0x20,
    0x22, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x22, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x73, 0x0a,
    0x20, 0x20, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x61, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x61,
    0x6e, 0x64, 0x20, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20,
    0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x75, 0x73, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c,
    0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x72, 0x72,
    0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65,
    0x20, 0x74, 0x79, 0x70, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20,
    0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x61,
    0x70, 0x2e, 0x0a, 0x20, 0x2d, 0x20, 0x43, 0x6f, 0x64, 0x65, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68,
    0x20, 0x74, 0x72, 0x69, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70,
    0x72, 0x65, 0x74, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x73, 0x68,
    0x6f, 0x75, 0x6c, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, 0x20, 0x62, 0x65,
    0x20, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x20, 0x20,
    0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x6f, 0x73, 0x65, 0x20, 0x74, 0x68, 0x61,
    0x74, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x75, 0x6e, 0x64,
    0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x6d, 0x6f, 0x72, 0x65,
    0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
    0x6f, 0x6e, 0x73, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x62, 0x65, 0x20,
    0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00,
    0x04, 0x12, 0x04, 0xa4, 0x04, 0x02, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x06,
    0x12, 0x04, 0xa4, 0x04, 0x0b, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x01, 0x12,
    0x04, 0xa4, 0x04, 0x14, 0x1c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x02, 0x00, 0x03, 0x12, 0x04,
    0xa4, 0x04, 0x1f, 0x20, 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x10, 0x03, 0x00, 0x12, 0x06, 0xa5, 0x04,
    0x02, 0xea, 0x04, 0x03, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x10, 0x03, 0x00, 0x01, 0x12, 0x04, 0xa5,
    0x04, 0x0a, 0x12, 0x0a, 0x83, 0x07, 0x0a, 0x06, 0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04,
    0xbd, 0x04, 0x04, 0x2a, 0x1a, 0xf2, 0x06, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69,
    0x65, 0x73, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66,
    0x20, 0x74, 0x68, 0x65, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
    0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, 0x66,
    0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x0a, 0x20, 0x6c, 0x6f,
    0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x20, 0x45, 0x61, 0x63, 0x68, 0x20, 0x65,
    0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c,
    0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x20, 0x69,
    0x6e, 0x64, 0x65, 0x78, 0x2e, 0x20, 0x20, 0x54, 0x68, 0x65, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x6d,
    0x20, 0x61, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x0a, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x72, 0x6f, 0x6f, 0x74, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
    0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x20, 0x46,
    0x6f, 0x72, 0x0a, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x69,
    0x73, 0x20, 0x70, 0x61, 0x74, 0x68, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x20, 0x34, 0x2c, 0x20,
    0x33, 0x2c, 0x20, 0x32, 0x2c, 0x20, 0x37, 0x2c, 0x20, 0x31, 0x20, 0x5d, 0x0a, 0x20, 0x72, 0x65,
    0x66, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x66, 0x69, 0x6c, 0x65,
    0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x28, 0x33, 0x29,
    0x20, 0x20, 0x2f, 0x2f, 0x20, 0x34, 0x2c, 0x20, 0x33, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x2e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x28, 0x37, 0x29, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x32, 0x2c, 0x20, 0x37, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x29, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x31, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69,
    0x73, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65,
    0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x65,
    0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x66,
    0x69, 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x34, 0x3a, 0x0a, 0x20,
    0x20, 0x20, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72,
    0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61,
    0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x20, 0x3d, 0x20, 0x34, 0x3b, 0x0a, 0x20, 0x61, 0x6e,
    0x64, 0x20, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74,
    0x6f, 0x2e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x68, 0x61, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c,
    0x64, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x32, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x72,
    0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73,
    0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x65,
    0x6c, 0x64, 0x20, 0x3d, 0x20, 0x32, 0x3b, 0x0a, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x46, 0x69, 0x65,
    0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74,
    0x6f, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x68, 0x61, 0x73, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64,
    0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x31, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x6f, 0x70,
    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61,
    0x6d, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x3b, 0x0a, 0x0a, 0x20, 0x54, 0x68, 0x75, 0x73, 0x2c, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x20, 0x70, 0x61, 0x74, 0x68, 0x20, 0x67,
    0x69, 0x76, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
    0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x6e, 0x61, 0x6d,
    0x65, 0x2e, 0x20, 0x20, 0x49, 0x66, 0x20, 0x77, 0x65, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65,
    0x64, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d,
    0x65, 0x6e, 0x74, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x5b, 0x20, 0x34, 0x2c, 0x20, 0x33, 0x2c, 0x20,
    0x32, 0x2c, 0x20, 0x37, 0x20, 0x5d, 0x0a, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x70, 0x61, 0x74,
    0x68, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x77, 0x68, 0x6f, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x64, 0x65, 0x63, 0x6c,
    0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68,
    0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x0a, 0x20, 0x6f, 0x66, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65,
    0x20, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x65, 0x6d,
    0x69, 0x63, 0x6f, 0x6c, 0x6f, 0x6e, 0x29, 0x2e, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03,
    0x00, 0x02, 0x00, 0x04, 0x12, 0x04, 0xbd, 0x04, 0x04, 0x0c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10,
    0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x04, 0xbd, 0x04, 0x0d, 0x12, 0x0a, 0x0f, 0x0a, 0x07, 0x04,
    0x10, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xbd, 0x04, 0x13, 0x17, 0x0a, 0x0f, 0x0a, 0x07,
    0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x04, 0xbd, 0x04, 0x1a, 0x1b, 0x0a, 0x0f, 0x0a,
    0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x08, 0x12, 0x04, 0xbd, 0x04, 0x1c, 0x29, 0x0a, 0x12,
    0x0a, 0x0a, 0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x08, 0xe7, 0x07, 0x00, 0x12, 0x04, 0xbd, 0x04,
    0x1d, 0x28, 0x0a, 0x13, 0x0a, 0x0b, 0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x08, 0xe7, 0x07, 0x00,
    0x02, 0x12, 0x04, 0xbd, 0x04, 0x1d, 0x23, 0x0a, 0x14, 0x0a, 0x0c, 0x04, 0x10, 0x03, 0x00, 0x02,
    0x00, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x00, 0x12, 0x04, 0xbd, 0x04, 0x1d, 0x23, 0x0a, 0x15, 0x0a,
    0x0d, 0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04,
    0xbd, 0x04, 0x1d, 0x23, 0x0a, 0x13, 0x0a, 0x0b, 0x04, 0x10, 0x03, 0x00, 0x02, 0x00, 0x08, 0xe7,
    0x07, 0x00, 0x03, 0x12, 0x04, 0xbd, 0x04, 0x24, 0x28, 0x0a, 0xd2, 0x02, 0x0a, 0x06, 0x04, 0x10,
    0x03, 0x00, 0x02, 0x01, 0x12, 0x04, 0xc4, 0x04, 0x04, 0x2a, 0x1a, 0xc1, 0x02, 0x20, 0x41, 0x6c,
    0x77, 0x61, 0x79, 0x73, 0x20, 0x68, 0x61, 0x73, 0x20, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79,
    0x20, 0x74, 0x68, 0x72, 0x65, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x6f, 0x75, 0x72, 0x20, 0x65,
    0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x3a, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x6c,
    0x69, 0x6e, 0x65, 0x2c, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
    0x6e, 0x2c, 0x0a, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x28, 0x6f, 0x70,
    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2c, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73,
    0x65, 0x20, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x64, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x61,
    0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x29, 0x2c, 0x20, 0x65,
    0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x73,
    0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74,
    0x6f, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64,
    0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x2e,
    0x20, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6c, 0x69, 0x6e, 0x65,
    0x0a, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x20, 0x6e, 0x75, 0x6d,
    0x62, 0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x7a, 0x65, 0x72, 0x6f, 0x2d, 0x62, 0x61,
    0x73, 0x65, 0x64, 0x20, 0x2d, 0x2d, 0x20, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79,
    0x20, 0x79, 0x6f, 0x75, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20, 0x74,
    0x6f, 0x20, 0x61, 0x64, 0x64, 0x0a, 0x20, 0x31, 0x20, 0x74, 0x6f, 0x20, 0x65, 0x61, 0x63, 0x68,
    0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x69,
    0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x0a, 0x0a, 0x0f,
    0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x04, 0x12, 0x04, 0xc4, 0x04, 0x04, 0x0c, 0x0a,
    0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x04, 0xc4, 0x04, 0x0d, 0x12,
    0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xc4, 0x04, 0x13,
    0x17, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x04, 0xc4, 0x04,
    0x1a, 0x1b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x08, 0x12, 0x04, 0xc4,
    0x04, 0x1c, 0x29, 0x0a, 0x12, 0x0a, 0x0a, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x08, 0xe7, 0x07,
    0x00, 0x12, 0x04, 0xc4, 0x04, 0x1d, 0x28, 0x0a, 0x13, 0x0a, 0x0b, 0x04, 0x10, 0x03, 0x00, 0x02,
    0x01, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x12, 0x04, 0xc4, 0x04, 0x1d, 0x23, 0x0a, 0x14, 0x0a, 0x0c,
    0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x08, 0xe7, 0x07, 0x00, 0x02, 0x00, 0x12, 0x04, 0xc4, 0x04,
    0x1d, 0x23, 0x0a, 0x15, 0x0a, 0x0d, 0x04, 0x10, 0x03, 0x00, 0x02, 0x01, 0x08, 0xe7, 0x07, 0x00,
    0x02, 0x00, 0x01, 0x12, 0x04, 0xc4, 0x04, 0x1d, 0x23, 0x0a, 0x13, 0x0a, 0x0b, 0x04, 0x10, 0x03,
    0x00, 0x02, 0x01, 0x08, 0xe7, 0x07, 0x00, 0x03, 0x12, 0x04, 0xc4, 0x04, 0x24, 0x28, 0x0a, 0xd9,
    0x08, 0x0a, 0x06, 0x04, 0x10, 0x03, 0x00, 0x02, 0x02, 0x12, 0x04, 0xe8, 0x04, 0x04, 0x29, 0x1a,
    0xc8, 0x08, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x53, 0x6f, 0x75, 0x72, 0x63,
    0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x20,
    0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x74, 0x68, 0x65,
    0x73, 0x65, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x79, 0x0a, 0x20, 0x63, 0x6f, 0x6d, 0x6d,
    0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x62,
    0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
    0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x20,
    0x62, 0x65, 0x0a, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20,
    0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
    0x0a, 0x0a, 0x20, 0x41, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x6c,
    0x69, 0x6e, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x70, 0x70,
    0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x63,
    0x75, 0x74, 0x69, 0x76, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x2c, 0x20, 0x77, 0x69, 0x74,
    0x68, 0x20, 0x6e, 0x6f, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x0a, 0x20, 0x74, 0x6f, 0x6b, 0x65,
    0x6e, 0x73, 0x20, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x20,
    0x74, 0x68, 0x6f, 0x73, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x2c, 0x20, 0x77, 0x69, 0x6c,
    0x6c, 0x20, 0x62, 0x65, 0x20, 0x74, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20,
    0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
    0x2e, 0x0a, 0x0a, 0x20, 0x4f, 0x6e, 0x6c, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6d,
    0x6d, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x73, 0x20,
    0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x3b, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e,
    0x74, 0x20, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x20, 0x28, 0x65, 0x2e, 0x67, 0x2e, 0x20,
    0x2f, 0x2f, 0x29, 0x20, 0x61, 0x72, 0x65, 0x0a, 0x20, 0x73, 0x74, 0x72, 0x69, 0x70, 0x70, 0x65,
    0x64, 0x20, 0x6f, 0x75, 0x74, 0x2e, 0x20, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x6c, 0x6f, 0x63,
    0x6b, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2c, 0x20, 0x6c, 0x65, 0x61, 0x64,
    0x69, 0x6e, 0x67, 0x20, 0x77, 0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x61,
    0x6e, 0x64, 0x20, 0x61, 0x6e, 0x20, 0x61, 0x73, 0x74, 0x65, 0x72, 0x69, 0x73, 0x6b, 0x0a, 0x20,
    0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x73, 0x74, 0x72, 0x69, 0x70, 0x70, 0x65, 0x64,
    0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e,
    0x69, 0x6e, 0x67, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x61, 0x63, 0x68, 0x20, 0x6c, 0x69, 0x6e, 0x65,
    0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20,
    0x66, 0x69, 0x72, 0x73, 0x74, 0x2e, 0x0a, 0x20, 0x4e, 0x65, 0x77, 0x6c, 0x69, 0x6e, 0x65, 0x73,
    0x20, 0x61, 0x72, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e,
    0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x0a, 0x0a, 0x20, 0x45,
    0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x3a, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x6f, 0x70, 0x74,
    0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x20, 0x66, 0x6f, 0x6f, 0x20,
    0x3d, 0x20, 0x31, 0x3b, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
    0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x6f,
    0x2e, 0x0a, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x20,
    0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x61, 0x72, 0x2e,
    0x0a, 0x20, 0x20, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74,
    0x33, 0x32, 0x20, 0x62, 0x61, 0x72, 0x20, 0x3d, 0x20, 0x32, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20,
    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20,
    0x62, 0x61, 0x7a, 0x20, 0x3d, 0x20, 0x33, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x43,
    0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20,
    0x74, 0x6f, 0x20, 0x62, 0x61, 0x7a, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6e,
    0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63,
    0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x61, 0x7a, 0x2e, 0x0a, 0x0a, 0x20, 0x20, 0x20,
    0x2f, 0x2f, 0x20, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63,
    0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x71, 0x75, 0x78, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x2f,
    0x2f, 0x0a, 0x20, 0x20, 0x20, 0x2f, 0x2f, 0x20, 0x41, 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20,
    0x6c, 0x69, 0x6e, 0x65, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f,
    0x20, 0x71, 0x75, 0x78, 0x2e, 0x0a, 0x20, 0x20, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61,
    0x6c, 0x20, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x20, 0x71, 0x75, 0x78, 0x20, 0x3d, 0x20, 0x34,
    0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x73,
    0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x63, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x3d, 0x20, 0x35, 0x3b,
    0x0a, 0x20, 0x20, 0x20, 0x2f, 0x2a, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x63, 0x6f, 0x6d,
    0x6d, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x0a, 0x20, 0x20,
    0x20, 0x20, 0x2a, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x72, 0x67, 0x65, 0x2e, 0x20, 0x20, 0x4c,
    0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x73, 0x74, 0x65, 0x72, 0x69, 0x73, 0x6b, 0x73,
    0x0a, 0x20, 0x20, 0x20, 0x20, 0x2a, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, 0x20, 0x72,
    0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x2e, 0x20, 0x2a, 0x2f, 0x0a, 0x20, 0x20, 0x20, 0x2f, 0x2a,
    0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x61,
    0x74, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2a,
    0x20, 0x67, 0x72, 0x61, 0x75, 0x6c, 0x74, 0x2e, 0x20, 0x2a, 0x2f, 0x0a, 0x20, 0x20, 0x20, 0x6f,
    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x20, 0x67, 0x72,
    0x61, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x20, 0x36, 0x3b, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10,
    0x03, 0x00, 0x02, 0x02, 0x04, 0x12, 0x04, 0xe8, 0x04, 0x04, 0x0c, 0x0a, 0x0f, 0x0a, 0x07, 0x04,
    0x10, 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x04, 0xe8, 0x04, 0x0d, 0x13, 0x0a, 0x0f, 0x0a, 0x07,
    0x04, 0x10, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xe8, 0x04, 0x14, 0x24, 0x0a, 0x0f, 0x0a,
    0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x04, 0xe8, 0x04, 0x27, 0x28, 0x0a, 0x0e,
    0x0a, 0x06, 0x04, 0x10, 0x03, 0x00, 0x02, 0x03, 0x12, 0x04, 0xe9, 0x04, 0x04, 0x2a, 0x0a, 0x0f,
    0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x03, 0x04, 0x12, 0x04, 0xe9, 0x04, 0x04, 0x0c, 0x0a,
    0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x03, 0x05, 0x12, 0x04, 0xe9, 0x04, 0x0d, 0x13,
    0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x03, 0x01, 0x12, 0x04, 0xe9, 0x04, 0x14,
    0x25, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x10, 0x03, 0x00, 0x02, 0x03, 0x03, 0x12, 0x04, 0xe9, 0x04,
    0x28, 0x29,
];

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto };

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 {
    unsafe {
        file_descriptor_proto_lazy.get(|| {
            parse_descriptor_proto()
        })
    }
}