caffe2-proto 0.1.5-alpha.0

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct RecordRef {
    // message fields
    key: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional string key = 1;


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

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

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

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

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.key)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.key.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.key.as_ref() {
            os.write_string(1, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "key",
                |m: &RecordRef| { &m.key },
                |m: &mut RecordRef| { &mut m.key },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RecordRef>(
                "RecordRef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TensorDef {
    // message fields
    pub dims: ::std::vec::Vec<i64>,
    offset: ::std::option::Option<i64>,
    pub strides: ::std::vec::Vec<i64>,
    requires_grad: ::std::option::Option<bool>,
    data_type: ::std::option::Option<super::caffe2::TensorProto_DataType>,
    pub data: ::protobuf::SingularPtrField<RecordRef>,
    device: ::protobuf::SingularField<::std::string::String>,
    is_quantized: ::std::option::Option<bool>,
    scale: ::std::option::Option<f64>,
    zero_point: ::std::option::Option<i64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated int64 dims = 1;


    pub fn get_dims(&self) -> &[i64] {
        &self.dims
    }
    pub fn clear_dims(&mut self) {
        self.dims.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_dims(&mut self) -> &mut ::std::vec::Vec<i64> {
        &mut self.dims
    }

    // Take field
    pub fn take_dims(&mut self) -> ::std::vec::Vec<i64> {
        ::std::mem::replace(&mut self.dims, ::std::vec::Vec::new())
    }

    // optional int64 offset = 2;


    pub fn get_offset(&self) -> i64 {
        self.offset.unwrap_or(0)
    }
    pub fn clear_offset(&mut self) {
        self.offset = ::std::option::Option::None;
    }

    pub fn has_offset(&self) -> bool {
        self.offset.is_some()
    }

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

    // repeated int64 strides = 3;


    pub fn get_strides(&self) -> &[i64] {
        &self.strides
    }
    pub fn clear_strides(&mut self) {
        self.strides.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_strides(&mut self) -> &mut ::std::vec::Vec<i64> {
        &mut self.strides
    }

    // Take field
    pub fn take_strides(&mut self) -> ::std::vec::Vec<i64> {
        ::std::mem::replace(&mut self.strides, ::std::vec::Vec::new())
    }

    // optional bool requires_grad = 4;


    pub fn get_requires_grad(&self) -> bool {
        self.requires_grad.unwrap_or(false)
    }
    pub fn clear_requires_grad(&mut self) {
        self.requires_grad = ::std::option::Option::None;
    }

    pub fn has_requires_grad(&self) -> bool {
        self.requires_grad.is_some()
    }

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

    // optional .caffe2.TensorProto.DataType data_type = 5;


    pub fn get_data_type(&self) -> super::caffe2::TensorProto_DataType {
        self.data_type.unwrap_or(super::caffe2::TensorProto_DataType::UNDEFINED)
    }
    pub fn clear_data_type(&mut self) {
        self.data_type = ::std::option::Option::None;
    }

    pub fn has_data_type(&self) -> bool {
        self.data_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_data_type(&mut self, v: super::caffe2::TensorProto_DataType) {
        self.data_type = ::std::option::Option::Some(v);
    }

    // optional .torch.RecordRef data = 6;


    pub fn get_data(&self) -> &RecordRef {
        self.data.as_ref().unwrap_or_else(|| <RecordRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

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

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

    // Take field
    pub fn take_data(&mut self) -> RecordRef {
        self.data.take().unwrap_or_else(|| RecordRef::new())
    }

    // optional string device = 7;


    pub fn get_device(&self) -> &str {
        match self.device.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_device(&mut self) {
        self.device.clear();
    }

    pub fn has_device(&self) -> bool {
        self.device.is_some()
    }

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

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

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

    // optional bool is_quantized = 8;


    pub fn get_is_quantized(&self) -> bool {
        self.is_quantized.unwrap_or(false)
    }
    pub fn clear_is_quantized(&mut self) {
        self.is_quantized = ::std::option::Option::None;
    }

    pub fn has_is_quantized(&self) -> bool {
        self.is_quantized.is_some()
    }

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

    // optional double scale = 9;


    pub fn get_scale(&self) -> f64 {
        self.scale.unwrap_or(0.)
    }
    pub fn clear_scale(&mut self) {
        self.scale = ::std::option::Option::None;
    }

    pub fn has_scale(&self) -> bool {
        self.scale.is_some()
    }

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

    // optional int64 zero_point = 10;


    pub fn get_zero_point(&self) -> i64 {
        self.zero_point.unwrap_or(0)
    }
    pub fn clear_zero_point(&mut self) {
        self.zero_point = ::std::option::Option::None;
    }

    pub fn has_zero_point(&self) -> bool {
        self.zero_point.is_some()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.dims)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.offset = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_repeated_int64_into(wire_type, is, &mut self.strides)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.requires_grad = ::std::option::Option::Some(tmp);
                },
                5 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.data_type, 5, &mut self.unknown_fields)?
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.data)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_quantized = ::std::option::Option::Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_double()?;
                    self.scale = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.zero_point = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.dims {
            my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(v) = self.offset {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.strides {
            my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint);
        };
        if let Some(v) = self.requires_grad {
            my_size += 2;
        }
        if let Some(v) = self.data_type {
            my_size += ::protobuf::rt::enum_size(5, v);
        }
        if let Some(ref v) = self.data.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.device.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.is_quantized {
            my_size += 2;
        }
        if let Some(v) = self.scale {
            my_size += 9;
        }
        if let Some(v) = self.zero_point {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.dims {
            os.write_int64(1, *v)?;
        };
        if let Some(v) = self.offset {
            os.write_int64(2, v)?;
        }
        for v in &self.strides {
            os.write_int64(3, *v)?;
        };
        if let Some(v) = self.requires_grad {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.data_type {
            os.write_enum(5, ::protobuf::ProtobufEnum::value(&v))?;
        }
        if let Some(ref v) = self.data.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.device.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(v) = self.is_quantized {
            os.write_bool(8, v)?;
        }
        if let Some(v) = self.scale {
            os.write_double(9, v)?;
        }
        if let Some(v) = self.zero_point {
            os.write_int64(10, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "dims",
                |m: &TensorDef| { &m.dims },
                |m: &mut TensorDef| { &mut m.dims },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "offset",
                |m: &TensorDef| { &m.offset },
                |m: &mut TensorDef| { &mut m.offset },
            ));
            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "strides",
                |m: &TensorDef| { &m.strides },
                |m: &mut TensorDef| { &mut m.strides },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "requires_grad",
                |m: &TensorDef| { &m.requires_grad },
                |m: &mut TensorDef| { &mut m.requires_grad },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::caffe2::TensorProto_DataType>>(
                "data_type",
                |m: &TensorDef| { &m.data_type },
                |m: &mut TensorDef| { &mut m.data_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RecordRef>>(
                "data",
                |m: &TensorDef| { &m.data },
                |m: &mut TensorDef| { &mut m.data },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "device",
                |m: &TensorDef| { &m.device },
                |m: &mut TensorDef| { &mut m.device },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_quantized",
                |m: &TensorDef| { &m.is_quantized },
                |m: &mut TensorDef| { &mut m.is_quantized },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
                "scale",
                |m: &TensorDef| { &m.scale },
                |m: &mut TensorDef| { &mut m.scale },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "zero_point",
                |m: &TensorDef| { &m.zero_point },
                |m: &mut TensorDef| { &mut m.zero_point },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorDef>(
                "TensorDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for TensorDef {
    fn clear(&mut self) {
        self.dims.clear();
        self.offset = ::std::option::Option::None;
        self.strides.clear();
        self.requires_grad = ::std::option::Option::None;
        self.data_type = ::std::option::Option::None;
        self.data.clear();
        self.device.clear();
        self.is_quantized = ::std::option::Option::None;
        self.scale = ::std::option::Option::None;
        self.zero_point = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct AttributeDef {
    // message fields
    field_type: ::protobuf::SingularField<::std::string::String>,
    name: ::protobuf::SingularField<::std::string::String>,
    id: ::std::option::Option<i64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // required string type = 1;


    pub fn get_field_type(&self) -> &str {
        match self.field_type.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_field_type(&mut self) {
        self.field_type.clear();
    }

    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: ::std::string::String) {
        self.field_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_field_type(&mut self) -> &mut ::std::string::String {
        if self.field_type.is_none() {
            self.field_type.set_default();
        }
        self.field_type.as_mut().unwrap()
    }

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

    // required string name = 2;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    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(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name.set_default();
        }
        self.name.as_mut().unwrap()
    }

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

    // required int64 id = 3;


    pub fn get_id(&self) -> i64 {
        self.id.unwrap_or(0)
    }
    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

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

impl ::protobuf::Message for AttributeDef {
    fn is_initialized(&self) -> bool {
        if self.field_type.is_none() {
            return false;
        }
        if self.name.is_none() {
            return false;
        }
        if self.id.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.field_type)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.id = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.field_type.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.field_type.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.id {
            os.write_int64(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "type",
                |m: &AttributeDef| { &m.field_type },
                |m: &mut AttributeDef| { &mut m.field_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &AttributeDef| { &m.name },
                |m: &mut AttributeDef| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "id",
                |m: &AttributeDef| { &m.id },
                |m: &mut AttributeDef| { &mut m.id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<AttributeDef>(
                "AttributeDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for AttributeDef {
    fn clear(&mut self) {
        self.field_type.clear();
        self.name.clear();
        self.id = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ParameterDef {
    // message fields
    is_buffer: ::std::option::Option<bool>,
    tensor_id: ::std::option::Option<i64>,
    name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool is_buffer = 1;


    pub fn get_is_buffer(&self) -> bool {
        self.is_buffer.unwrap_or(false)
    }
    pub fn clear_is_buffer(&mut self) {
        self.is_buffer = ::std::option::Option::None;
    }

    pub fn has_is_buffer(&self) -> bool {
        self.is_buffer.is_some()
    }

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

    // optional int64 tensor_id = 2;


    pub fn get_tensor_id(&self) -> i64 {
        self.tensor_id.unwrap_or(0)
    }
    pub fn clear_tensor_id(&mut self) {
        self.tensor_id = ::std::option::Option::None;
    }

    pub fn has_tensor_id(&self) -> bool {
        self.tensor_id.is_some()
    }

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

    // optional string name = 3;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    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(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name.set_default();
        }
        self.name.as_mut().unwrap()
    }

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

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_buffer = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.tensor_id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.is_buffer {
            my_size += 2;
        }
        if let Some(v) = self.tensor_id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.is_buffer {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.tensor_id {
            os.write_int64(2, v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(3, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "is_buffer",
                |m: &ParameterDef| { &m.is_buffer },
                |m: &mut ParameterDef| { &mut m.is_buffer },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "tensor_id",
                |m: &ParameterDef| { &m.tensor_id },
                |m: &mut ParameterDef| { &mut m.tensor_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &ParameterDef| { &m.name },
                |m: &mut ParameterDef| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ParameterDef>(
                "ParameterDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ParameterDef {
    fn clear(&mut self) {
        self.is_buffer = ::std::option::Option::None;
        self.tensor_id = ::std::option::Option::None;
        self.name.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ModuleDef {
    // message fields
    pub submodules: ::protobuf::RepeatedField<ModuleDef>,
    pub torchscript_arena: ::protobuf::SingularPtrField<RecordRef>,
    pub caffe2_nets: ::protobuf::RepeatedField<super::caffe2::NetDef>,
    pub pickle_arena: ::protobuf::SingularPtrField<RecordRef>,
    pub cpp_arena: ::protobuf::SingularPtrField<RecordRef>,
    pub parameters: ::protobuf::RepeatedField<ParameterDef>,
    name: ::protobuf::SingularField<::std::string::String>,
    optimize: ::std::option::Option<bool>,
    pub attributes: ::protobuf::RepeatedField<AttributeDef>,
    get_state_attribute_id: ::std::option::Option<i64>,
    pub torchscript_debug_arena: ::protobuf::SingularPtrField<RecordRef>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .torch.ModuleDef submodules = 1;


    pub fn get_submodules(&self) -> &[ModuleDef] {
        &self.submodules
    }
    pub fn clear_submodules(&mut self) {
        self.submodules.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_submodules(&mut self) -> &mut ::protobuf::RepeatedField<ModuleDef> {
        &mut self.submodules
    }

    // Take field
    pub fn take_submodules(&mut self) -> ::protobuf::RepeatedField<ModuleDef> {
        ::std::mem::replace(&mut self.submodules, ::protobuf::RepeatedField::new())
    }

    // optional .torch.RecordRef torchscript_arena = 2;


    pub fn get_torchscript_arena(&self) -> &RecordRef {
        self.torchscript_arena.as_ref().unwrap_or_else(|| <RecordRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_torchscript_arena(&mut self) {
        self.torchscript_arena.clear();
    }

    pub fn has_torchscript_arena(&self) -> bool {
        self.torchscript_arena.is_some()
    }

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

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

    // Take field
    pub fn take_torchscript_arena(&mut self) -> RecordRef {
        self.torchscript_arena.take().unwrap_or_else(|| RecordRef::new())
    }

    // repeated .caffe2.NetDef caffe2_nets = 3;


    pub fn get_caffe2_nets(&self) -> &[super::caffe2::NetDef] {
        &self.caffe2_nets
    }
    pub fn clear_caffe2_nets(&mut self) {
        self.caffe2_nets.clear();
    }

    // Param is passed by value, moved
    pub fn set_caffe2_nets(&mut self, v: ::protobuf::RepeatedField<super::caffe2::NetDef>) {
        self.caffe2_nets = v;
    }

    // Mutable pointer to the field.
    pub fn mut_caffe2_nets(&mut self) -> &mut ::protobuf::RepeatedField<super::caffe2::NetDef> {
        &mut self.caffe2_nets
    }

    // Take field
    pub fn take_caffe2_nets(&mut self) -> ::protobuf::RepeatedField<super::caffe2::NetDef> {
        ::std::mem::replace(&mut self.caffe2_nets, ::protobuf::RepeatedField::new())
    }

    // optional .torch.RecordRef pickle_arena = 4;


    pub fn get_pickle_arena(&self) -> &RecordRef {
        self.pickle_arena.as_ref().unwrap_or_else(|| <RecordRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_pickle_arena(&mut self) {
        self.pickle_arena.clear();
    }

    pub fn has_pickle_arena(&self) -> bool {
        self.pickle_arena.is_some()
    }

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

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

    // Take field
    pub fn take_pickle_arena(&mut self) -> RecordRef {
        self.pickle_arena.take().unwrap_or_else(|| RecordRef::new())
    }

    // optional .torch.RecordRef cpp_arena = 5;


    pub fn get_cpp_arena(&self) -> &RecordRef {
        self.cpp_arena.as_ref().unwrap_or_else(|| <RecordRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_cpp_arena(&mut self) {
        self.cpp_arena.clear();
    }

    pub fn has_cpp_arena(&self) -> bool {
        self.cpp_arena.is_some()
    }

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

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

    // Take field
    pub fn take_cpp_arena(&mut self) -> RecordRef {
        self.cpp_arena.take().unwrap_or_else(|| RecordRef::new())
    }

    // repeated .torch.ParameterDef parameters = 6;


    pub fn get_parameters(&self) -> &[ParameterDef] {
        &self.parameters
    }
    pub fn clear_parameters(&mut self) {
        self.parameters.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_parameters(&mut self) -> &mut ::protobuf::RepeatedField<ParameterDef> {
        &mut self.parameters
    }

    // Take field
    pub fn take_parameters(&mut self) -> ::protobuf::RepeatedField<ParameterDef> {
        ::std::mem::replace(&mut self.parameters, ::protobuf::RepeatedField::new())
    }

    // optional string name = 7;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    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(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name.set_default();
        }
        self.name.as_mut().unwrap()
    }

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

    // optional bool optimize = 8;


    pub fn get_optimize(&self) -> bool {
        self.optimize.unwrap_or(false)
    }
    pub fn clear_optimize(&mut self) {
        self.optimize = ::std::option::Option::None;
    }

    pub fn has_optimize(&self) -> bool {
        self.optimize.is_some()
    }

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

    // repeated .torch.AttributeDef attributes = 9;


    pub fn get_attributes(&self) -> &[AttributeDef] {
        &self.attributes
    }
    pub fn clear_attributes(&mut self) {
        self.attributes.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_attributes(&mut self) -> &mut ::protobuf::RepeatedField<AttributeDef> {
        &mut self.attributes
    }

    // Take field
    pub fn take_attributes(&mut self) -> ::protobuf::RepeatedField<AttributeDef> {
        ::std::mem::replace(&mut self.attributes, ::protobuf::RepeatedField::new())
    }

    // optional int64 get_state_attribute_id = 10;


    pub fn get_get_state_attribute_id(&self) -> i64 {
        self.get_state_attribute_id.unwrap_or(0)
    }
    pub fn clear_get_state_attribute_id(&mut self) {
        self.get_state_attribute_id = ::std::option::Option::None;
    }

    pub fn has_get_state_attribute_id(&self) -> bool {
        self.get_state_attribute_id.is_some()
    }

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

    // optional .torch.RecordRef torchscript_debug_arena = 11;


    pub fn get_torchscript_debug_arena(&self) -> &RecordRef {
        self.torchscript_debug_arena.as_ref().unwrap_or_else(|| <RecordRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_torchscript_debug_arena(&mut self) {
        self.torchscript_debug_arena.clear();
    }

    pub fn has_torchscript_debug_arena(&self) -> bool {
        self.torchscript_debug_arena.is_some()
    }

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

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

    // Take field
    pub fn take_torchscript_debug_arena(&mut self) -> RecordRef {
        self.torchscript_debug_arena.take().unwrap_or_else(|| RecordRef::new())
    }
}

impl ::protobuf::Message for ModuleDef {
    fn is_initialized(&self) -> bool {
        for v in &self.submodules {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.torchscript_arena {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.caffe2_nets {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.pickle_arena {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.cpp_arena {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.parameters {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.attributes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.torchscript_debug_arena {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.submodules)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.torchscript_arena)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.caffe2_nets)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.pickle_arena)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cpp_arena)?;
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.parameters)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.optimize = ::std::option::Option::Some(tmp);
                },
                9 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.attributes)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.get_state_attribute_id = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.torchscript_debug_arena)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.submodules {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.torchscript_arena.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.caffe2_nets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.pickle_arena.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.cpp_arena.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.parameters {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.optimize {
            my_size += 2;
        }
        for value in &self.attributes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.get_state_attribute_id {
            my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.torchscript_debug_arena.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.submodules {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.torchscript_arena.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.caffe2_nets {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.pickle_arena.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.cpp_arena.as_ref() {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.parameters {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(7, &v)?;
        }
        if let Some(v) = self.optimize {
            os.write_bool(8, v)?;
        }
        for v in &self.attributes {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.get_state_attribute_id {
            os.write_int64(10, v)?;
        }
        if let Some(ref v) = self.torchscript_debug_arena.as_ref() {
            os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ModuleDef>>(
                "submodules",
                |m: &ModuleDef| { &m.submodules },
                |m: &mut ModuleDef| { &mut m.submodules },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RecordRef>>(
                "torchscript_arena",
                |m: &ModuleDef| { &m.torchscript_arena },
                |m: &mut ModuleDef| { &mut m.torchscript_arena },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::caffe2::NetDef>>(
                "caffe2_nets",
                |m: &ModuleDef| { &m.caffe2_nets },
                |m: &mut ModuleDef| { &mut m.caffe2_nets },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RecordRef>>(
                "pickle_arena",
                |m: &ModuleDef| { &m.pickle_arena },
                |m: &mut ModuleDef| { &mut m.pickle_arena },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RecordRef>>(
                "cpp_arena",
                |m: &ModuleDef| { &m.cpp_arena },
                |m: &mut ModuleDef| { &mut m.cpp_arena },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ParameterDef>>(
                "parameters",
                |m: &ModuleDef| { &m.parameters },
                |m: &mut ModuleDef| { &mut m.parameters },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &ModuleDef| { &m.name },
                |m: &mut ModuleDef| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "optimize",
                |m: &ModuleDef| { &m.optimize },
                |m: &mut ModuleDef| { &mut m.optimize },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AttributeDef>>(
                "attributes",
                |m: &ModuleDef| { &m.attributes },
                |m: &mut ModuleDef| { &mut m.attributes },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "get_state_attribute_id",
                |m: &ModuleDef| { &m.get_state_attribute_id },
                |m: &mut ModuleDef| { &mut m.get_state_attribute_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RecordRef>>(
                "torchscript_debug_arena",
                |m: &ModuleDef| { &m.torchscript_debug_arena },
                |m: &mut ModuleDef| { &mut m.torchscript_debug_arena },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ModuleDef>(
                "ModuleDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ModuleDef {
    fn clear(&mut self) {
        self.submodules.clear();
        self.torchscript_arena.clear();
        self.caffe2_nets.clear();
        self.pickle_arena.clear();
        self.cpp_arena.clear();
        self.parameters.clear();
        self.name.clear();
        self.optimize = ::std::option::Option::None;
        self.attributes.clear();
        self.get_state_attribute_id = ::std::option::Option::None;
        self.torchscript_debug_arena.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct LibDef {
    // message fields
    pub torchscript_arena: ::protobuf::SingularPtrField<RecordRef>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional .torch.RecordRef torchscript_arena = 1;


    pub fn get_torchscript_arena(&self) -> &RecordRef {
        self.torchscript_arena.as_ref().unwrap_or_else(|| <RecordRef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_torchscript_arena(&mut self) {
        self.torchscript_arena.clear();
    }

    pub fn has_torchscript_arena(&self) -> bool {
        self.torchscript_arena.is_some()
    }

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

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

    // Take field
    pub fn take_torchscript_arena(&mut self) -> RecordRef {
        self.torchscript_arena.take().unwrap_or_else(|| RecordRef::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.torchscript_arena)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.torchscript_arena.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RecordRef>>(
                "torchscript_arena",
                |m: &LibDef| { &m.torchscript_arena },
                |m: &mut LibDef| { &mut m.torchscript_arena },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<LibDef>(
                "LibDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ModelDef {
    // message fields
    proto_version: ::std::option::Option<i64>,
    pub main_module: ::protobuf::SingularPtrField<ModuleDef>,
    producer_name: ::protobuf::SingularField<::std::string::String>,
    producer_version: ::protobuf::SingularField<::std::string::String>,
    pub tensors: ::protobuf::RepeatedField<TensorDef>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int64 proto_version = 1;


    pub fn get_proto_version(&self) -> i64 {
        self.proto_version.unwrap_or(0)
    }
    pub fn clear_proto_version(&mut self) {
        self.proto_version = ::std::option::Option::None;
    }

    pub fn has_proto_version(&self) -> bool {
        self.proto_version.is_some()
    }

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

    // optional .torch.ModuleDef main_module = 2;


    pub fn get_main_module(&self) -> &ModuleDef {
        self.main_module.as_ref().unwrap_or_else(|| <ModuleDef as ::protobuf::Message>::default_instance())
    }
    pub fn clear_main_module(&mut self) {
        self.main_module.clear();
    }

    pub fn has_main_module(&self) -> bool {
        self.main_module.is_some()
    }

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

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

    // Take field
    pub fn take_main_module(&mut self) -> ModuleDef {
        self.main_module.take().unwrap_or_else(|| ModuleDef::new())
    }

    // optional string producer_name = 3;


    pub fn get_producer_name(&self) -> &str {
        match self.producer_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_producer_name(&mut self) {
        self.producer_name.clear();
    }

    pub fn has_producer_name(&self) -> bool {
        self.producer_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_producer_name(&mut self, v: ::std::string::String) {
        self.producer_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_producer_name(&mut self) -> &mut ::std::string::String {
        if self.producer_name.is_none() {
            self.producer_name.set_default();
        }
        self.producer_name.as_mut().unwrap()
    }

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

    // optional string producer_version = 4;


    pub fn get_producer_version(&self) -> &str {
        match self.producer_version.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_producer_version(&mut self) {
        self.producer_version.clear();
    }

    pub fn has_producer_version(&self) -> bool {
        self.producer_version.is_some()
    }

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

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

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

    // repeated .torch.TensorDef tensors = 5;


    pub fn get_tensors(&self) -> &[TensorDef] {
        &self.tensors
    }
    pub fn clear_tensors(&mut self) {
        self.tensors.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_tensors(&mut self) -> &mut ::protobuf::RepeatedField<TensorDef> {
        &mut self.tensors
    }

    // Take field
    pub fn take_tensors(&mut self) -> ::protobuf::RepeatedField<TensorDef> {
        ::std::mem::replace(&mut self.tensors, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ModelDef {
    fn is_initialized(&self) -> bool {
        for v in &self.main_module {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.tensors {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.proto_version = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.main_module)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.producer_name)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.producer_version)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tensors)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.proto_version {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.main_module.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.producer_name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(ref v) = self.producer_version.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        for value in &self.tensors {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.proto_version {
            os.write_int64(1, v)?;
        }
        if let Some(ref v) = self.main_module.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.producer_name.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(ref v) = self.producer_version.as_ref() {
            os.write_string(4, &v)?;
        }
        for v in &self.tensors {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "proto_version",
                |m: &ModelDef| { &m.proto_version },
                |m: &mut ModelDef| { &mut m.proto_version },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ModuleDef>>(
                "main_module",
                |m: &ModelDef| { &m.main_module },
                |m: &mut ModelDef| { &mut m.main_module },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "producer_name",
                |m: &ModelDef| { &m.producer_name },
                |m: &mut ModelDef| { &mut m.producer_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "producer_version",
                |m: &ModelDef| { &m.producer_version },
                |m: &mut ModelDef| { &mut m.producer_version },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TensorDef>>(
                "tensors",
                |m: &ModelDef| { &m.tensors },
                |m: &mut ModelDef| { &mut m.tensors },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ModelDef>(
                "ModelDef",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ModelDef {
    fn clear(&mut self) {
        self.proto_version = ::std::option::Option::None;
        self.main_module.clear();
        self.producer_name.clear();
        self.producer_version.clear();
        self.tensors.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ProtoVersion {
    PROTO_VERSION_NEWEST = 6,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<ProtoVersion> {
        match value {
            6 => ::std::option::Option::Some(ProtoVersion::PROTO_VERSION_NEWEST),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ProtoVersion] = &[
            ProtoVersion::PROTO_VERSION_NEWEST,
        ];
        values
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x20pytorch/caffe2/proto/torch.proto\x12\x05torch\x1a!pytorch/caffe2/p\
    roto/caffe2.proto\"\x1d\n\tRecordRef\x12\x10\n\x03key\x18\x01\x20\x01(\t\
    R\x03key\"\xc7\x02\n\tTensorDef\x12\x12\n\x04dims\x18\x01\x20\x03(\x03R\
    \x04dims\x12\x16\n\x06offset\x18\x02\x20\x01(\x03R\x06offset\x12\x18\n\
    \x07strides\x18\x03\x20\x03(\x03R\x07strides\x12#\n\rrequires_grad\x18\
    \x04\x20\x01(\x08R\x0crequiresGrad\x129\n\tdata_type\x18\x05\x20\x01(\
    \x0e2\x1c.caffe2.TensorProto.DataTypeR\x08dataType\x12$\n\x04data\x18\
    \x06\x20\x01(\x0b2\x10.torch.RecordRefR\x04data\x12\x16\n\x06device\x18\
    \x07\x20\x01(\tR\x06device\x12!\n\x0cis_quantized\x18\x08\x20\x01(\x08R\
    \x0bisQuantized\x12\x14\n\x05scale\x18\t\x20\x01(\x01R\x05scale\x12\x1d\
    \n\nzero_point\x18\n\x20\x01(\x03R\tzeroPoint\"F\n\x0cAttributeDef\x12\
    \x12\n\x04type\x18\x01\x20\x02(\tR\x04type\x12\x12\n\x04name\x18\x02\x20\
    \x02(\tR\x04name\x12\x0e\n\x02id\x18\x03\x20\x02(\x03R\x02id\"\\\n\x0cPa\
    rameterDef\x12\x1b\n\tis_buffer\x18\x01\x20\x01(\x08R\x08isBuffer\x12\
    \x1b\n\ttensor_id\x18\x02\x20\x01(\x03R\x08tensorId\x12\x12\n\x04name\
    \x18\x03\x20\x01(\tR\x04name\"\xaa\x04\n\tModuleDef\x120\n\nsubmodules\
    \x18\x01\x20\x03(\x0b2\x10.torch.ModuleDefR\nsubmodules\x12=\n\x11torchs\
    cript_arena\x18\x02\x20\x01(\x0b2\x10.torch.RecordRefR\x10torchscriptAre\
    na\x12/\n\x0bcaffe2_nets\x18\x03\x20\x03(\x0b2\x0e.caffe2.NetDefR\ncaffe\
    2Nets\x123\n\x0cpickle_arena\x18\x04\x20\x01(\x0b2\x10.torch.RecordRefR\
    \x0bpickleArena\x12-\n\tcpp_arena\x18\x05\x20\x01(\x0b2\x10.torch.Record\
    RefR\x08cppArena\x123\n\nparameters\x18\x06\x20\x03(\x0b2\x13.torch.Para\
    meterDefR\nparameters\x12\x12\n\x04name\x18\x07\x20\x01(\tR\x04name\x12\
    \x1a\n\x08optimize\x18\x08\x20\x01(\x08R\x08optimize\x123\n\nattributes\
    \x18\t\x20\x03(\x0b2\x13.torch.AttributeDefR\nattributes\x123\n\x16get_s\
    tate_attribute_id\x18\n\x20\x01(\x03R\x13getStateAttributeId\x12H\n\x17t\
    orchscript_debug_arena\x18\x0b\x20\x01(\x0b2\x10.torch.RecordRefR\x15tor\
    chscriptDebugArena\"G\n\x06LibDef\x12=\n\x11torchscript_arena\x18\x01\
    \x20\x01(\x0b2\x10.torch.RecordRefR\x10torchscriptArena\"\xea\x01\n\x08M\
    odelDef\x12#\n\rproto_version\x18\x01\x20\x01(\x03R\x0cprotoVersion\x121\
    \n\x0bmain_module\x18\x02\x20\x01(\x0b2\x10.torch.ModuleDefR\nmainModule\
    \x12#\n\rproducer_name\x18\x03\x20\x01(\tR\x0cproducerName\x12)\n\x10pro\
    ducer_version\x18\x04\x20\x01(\tR\x0fproducerVersion\x12*\n\x07tensors\
    \x18\x05\x20\x03(\x0b2\x10.torch.TensorDefR\x07tensorsJ\x04\x08\t\x10\nR\
    \x04libs*(\n\x0cProtoVersion\x12\x18\n\x14PROTO_VERSION_NEWEST\x10\x06J\
    \xad!\n\x06\x12\x04\0\0s\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\t\n\x02\
    \x03\0\x12\x03\x02\0+\n\x08\n\x01\x02\x12\x03\x04\0\x0e\n\n\n\x02\x04\0\
    \x12\x04\x06\0\x08\x01\n\n\n\x03\x04\0\x01\x12\x03\x06\x08\x11\n\x0b\n\
    \x04\x04\0\x02\0\x12\x03\x07\x02\x1a\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\
    \x07\x02\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x07\x0b\x11\n\x0c\n\x05\
    \x04\0\x02\0\x01\x12\x03\x07\x12\x15\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\
    \x07\x18\x19\n\n\n\x02\x04\x01\x12\x04\n\0\x1b\x01\n\n\n\x03\x04\x01\x01\
    \x12\x03\n\x08\x11\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x0b\x02\x1a\n\x0c\n\
    \x05\x04\x01\x02\0\x04\x12\x03\x0b\x02\n\n\x0c\n\x05\x04\x01\x02\0\x05\
    \x12\x03\x0b\x0b\x10\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x0b\x11\x15\n\
    \x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x0b\x18\x19\n\x0b\n\x04\x04\x01\x02\
    \x01\x12\x03\x0c\x02\x1c\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\x0c\x02\
    \n\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x0c\x0b\x10\n\x0c\n\x05\x04\
    \x01\x02\x01\x01\x12\x03\x0c\x11\x17\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\
    \x03\x0c\x1a\x1b\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\r\x02\x1d\n\x0c\n\
    \x05\x04\x01\x02\x02\x04\x12\x03\r\x02\n\n\x0c\n\x05\x04\x01\x02\x02\x05\
    \x12\x03\r\x0b\x10\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\r\x11\x18\n\
    \x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\r\x1b\x1c\n@\n\x04\x04\x01\x02\
    \x03\x12\x03\x0f\x02\"\x1a3\x20whether\x20we\x20compute\x20the\x20gradie\
    nt\x20for\x20the\x20parameter\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03\
    \x0f\x02\n\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03\x0f\x0b\x0f\n\x0c\n\
    \x05\x04\x01\x02\x03\x01\x12\x03\x0f\x10\x1d\n\x0c\n\x05\x04\x01\x02\x03\
    \x03\x12\x03\x0f\x20!\n\x0b\n\x04\x04\x01\x02\x04\x12\x03\x10\x025\n\x0c\
    \n\x05\x04\x01\x02\x04\x04\x12\x03\x10\x02\n\n\x0c\n\x05\x04\x01\x02\x04\
    \x06\x12\x03\x10\x0b&\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03\x10'0\n\
    \x0c\n\x05\x04\x01\x02\x04\x03\x12\x03\x1034\n\x0b\n\x04\x04\x01\x02\x05\
    \x12\x03\x12\x02\x1e\n\x0c\n\x05\x04\x01\x02\x05\x04\x12\x03\x12\x02\n\n\
    \x0c\n\x05\x04\x01\x02\x05\x06\x12\x03\x12\x0b\x14\n\x0c\n\x05\x04\x01\
    \x02\x05\x01\x12\x03\x12\x15\x19\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x03\
    \x12\x1c\x1d\n\x90\x01\n\x04\x04\x01\x02\x06\x12\x03\x16\x02\x1d\x1a\x82\
    \x01\x20device\x20field\x20stores\x20the\x20canonical\x20device\x20strin\
    g,\x20and\x20it\x20follows\x20the\n\x20format\x20below:\x20`(cpu|cuda)[:\
    <device-index>]`,\x20e.g.,\x20'cuda:0'\n\n\x0c\n\x05\x04\x01\x02\x06\x04\
    \x12\x03\x16\x02\n\n\x0c\n\x05\x04\x01\x02\x06\x05\x12\x03\x16\x0b\x11\n\
    \x0c\n\x05\x04\x01\x02\x06\x01\x12\x03\x16\x12\x18\n\x0c\n\x05\x04\x01\
    \x02\x06\x03\x12\x03\x16\x1b\x1c\n\x0b\n\x04\x04\x01\x02\x07\x12\x03\x18\
    \x02!\n\x0c\n\x05\x04\x01\x02\x07\x04\x12\x03\x18\x02\n\n\x0c\n\x05\x04\
    \x01\x02\x07\x05\x12\x03\x18\x0b\x0f\n\x0c\n\x05\x04\x01\x02\x07\x01\x12\
    \x03\x18\x10\x1c\n\x0c\n\x05\x04\x01\x02\x07\x03\x12\x03\x18\x1f\x20\n\
    \x0b\n\x04\x04\x01\x02\x08\x12\x03\x19\x02\x1c\n\x0c\n\x05\x04\x01\x02\
    \x08\x04\x12\x03\x19\x02\n\n\x0c\n\x05\x04\x01\x02\x08\x05\x12\x03\x19\
    \x0b\x11\n\x0c\n\x05\x04\x01\x02\x08\x01\x12\x03\x19\x12\x17\n\x0c\n\x05\
    \x04\x01\x02\x08\x03\x12\x03\x19\x1a\x1b\n\x0b\n\x04\x04\x01\x02\t\x12\
    \x03\x1a\x02!\n\x0c\n\x05\x04\x01\x02\t\x04\x12\x03\x1a\x02\n\n\x0c\n\
    \x05\x04\x01\x02\t\x05\x12\x03\x1a\x0b\x10\n\x0c\n\x05\x04\x01\x02\t\x01\
    \x12\x03\x1a\x11\x1b\n\x0c\n\x05\x04\x01\x02\t\x03\x12\x03\x1a\x1e\x20\n\
    \n\n\x02\x04\x02\x12\x04\x1d\0$\x01\n\n\n\x03\x04\x02\x01\x12\x03\x1d\
    \x08\x14\n.\n\x04\x04\x02\x02\0\x12\x03\x1f\x02\x1b\x1a!\x20The\x20mypy\
    \x20type\x20of\x20this\x20attribute\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\
    \x03\x1f\x02\n\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x1f\x0b\x11\n\x0c\n\
    \x05\x04\x02\x02\0\x01\x12\x03\x1f\x12\x16\n\x0c\n\x05\x04\x02\x02\0\x03\
    \x12\x03\x1f\x19\x1a\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\x20\x02\x1b\n\
    \x0c\n\x05\x04\x02\x02\x01\x04\x12\x03\x20\x02\n\n\x0c\n\x05\x04\x02\x02\
    \x01\x05\x12\x03\x20\x0b\x11\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03\x20\
    \x12\x16\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x20\x19\x1a\n*\n\x04\
    \x04\x02\x02\x02\x12\x03#\x02\x18\x1a\x1d\x20Offset\x20into\x20attribute\
    \x20table\n\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x03#\x02\n\n\x0c\n\x05\
    \x04\x02\x02\x02\x05\x12\x03#\x0b\x10\n\x0c\n\x05\x04\x02\x02\x02\x01\
    \x12\x03#\x11\x13\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03#\x16\x17\n\n\n\
    \x02\x04\x03\x12\x04&\0.\x01\n\n\n\x03\x04\x03\x01\x12\x03&\x08\x14\nD\n\
    \x04\x04\x03\x02\0\x12\x03(\x02\x1e\x1a7\x20whether\x20this\x20parameter\
    \x20is\x20registered\x20as\x20buffer\x20or\x20not\n\n\x0c\n\x05\x04\x03\
    \x02\0\x04\x12\x03(\x02\n\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03(\x0b\x0f\
    \n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03(\x10\x19\n\x0c\n\x05\x04\x03\x02\
    \0\x03\x12\x03(\x1c\x1d\nN\n\x04\x04\x03\x02\x01\x12\x03+\x02\x1f\x1aA\
    \x20the\x20offset\x20into\x20the\x20tensor\x20table\x20where\x20this\x20\
    parameter\x20is\x20stored\n\n\x0c\n\x05\x04\x03\x02\x01\x04\x12\x03+\x02\
    \n\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03+\x0b\x10\n\x0c\n\x05\x04\x03\
    \x02\x01\x01\x12\x03+\x11\x1a\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03+\
    \x1d\x1e\n\x0b\n\x04\x04\x03\x02\x02\x12\x03-\x02\x1b\n\x0c\n\x05\x04\
    \x03\x02\x02\x04\x12\x03-\x02\n\n\x0c\n\x05\x04\x03\x02\x02\x05\x12\x03-\
    \x0b\x11\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x03-\x12\x16\n\x0c\n\x05\
    \x04\x03\x02\x02\x03\x12\x03-\x19\x1a\n\n\n\x02\x04\x04\x12\x040\0P\x01\
    \n\n\n\x03\x04\x04\x01\x12\x030\x08\x11\n\x0b\n\x04\x04\x04\x02\0\x12\
    \x031\x02$\n\x0c\n\x05\x04\x04\x02\0\x04\x12\x031\x02\n\n\x0c\n\x05\x04\
    \x04\x02\0\x06\x12\x031\x0b\x14\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x031\
    \x15\x1f\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x031\"#\n\x0b\n\x04\x04\x04\
    \x02\x01\x12\x033\x02+\n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x033\x02\n\n\
    \x0c\n\x05\x04\x04\x02\x01\x06\x12\x033\x0b\x14\n\x0c\n\x05\x04\x04\x02\
    \x01\x01\x12\x033\x15&\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x033)*\n\x0b\
    \n\x04\x04\x04\x02\x02\x12\x035\x02)\n\x0c\n\x05\x04\x04\x02\x02\x04\x12\
    \x035\x02\n\n\x0c\n\x05\x04\x04\x02\x02\x06\x12\x035\x0b\x18\n\x0c\n\x05\
    \x04\x04\x02\x02\x01\x12\x035\x19$\n\x0c\n\x05\x04\x04\x02\x02\x03\x12\
    \x035'(\n\x83\x01\n\x04\x04\x04\x02\x03\x12\x039\x02&\x1av\x20because\
    \x20the\x20old\x20pickle\x20modules\x20may\x20not\x20be\x20supported\x20\
    by\x20torch_script,\n\x20have\x20to\x20stored\x20as\x20pickle_arena\x20a\
    t\x20this\x20moment.\n\n\x0c\n\x05\x04\x04\x02\x03\x04\x12\x039\x02\n\n\
    \x0c\n\x05\x04\x04\x02\x03\x06\x12\x039\x0b\x14\n\x0c\n\x05\x04\x04\x02\
    \x03\x01\x12\x039\x15!\n\x0c\n\x05\x04\x04\x02\x03\x03\x12\x039$%\n\x91\
    \x01\n\x04\x04\x04\x02\x04\x12\x03<\x02#\x1a\x83\x01\x20should\x20be\x20\
    exposed\x20by\x20the\x20Class\x20Archive,\x20so\x20user\x20can\x20save\n\
    \x20module\x20specific\x20data\x20which\x20cannot\x20be\x20store\x20in\
    \x20the\x20graph\x20or\x20torch_script\n\n\x0c\n\x05\x04\x04\x02\x04\x04\
    \x12\x03<\x02\n\n\x0c\n\x05\x04\x04\x02\x04\x06\x12\x03<\x0b\x14\n\x0c\n\
    \x05\x04\x04\x02\x04\x01\x12\x03<\x15\x1e\n\x0c\n\x05\x04\x04\x02\x04\
    \x03\x12\x03<!\"\n,\n\x04\x04\x04\x02\x05\x12\x03?\x02'\x1a\x1f\x20the\
    \x20parameters\x20of\x20this\x20module\n\n\x0c\n\x05\x04\x04\x02\x05\x04\
    \x12\x03?\x02\n\n\x0c\n\x05\x04\x04\x02\x05\x06\x12\x03?\x0b\x17\n\x0c\n\
    \x05\x04\x04\x02\x05\x01\x12\x03?\x18\"\n\x0c\n\x05\x04\x04\x02\x05\x03\
    \x12\x03?%&\n`\n\x04\x04\x04\x02\x06\x12\x03D\x02\x1b2S\x20the\x20names\
    \x20of\x20inputs\x20and\x20outputs\x20of\x20the\x20module\x20are\x20infe\
    rred\n\x20from\x20the\x20main\x20method.\n\n\x0c\n\x05\x04\x04\x02\x06\
    \x04\x12\x03D\x02\n\n\x0c\n\x05\x04\x04\x02\x06\x05\x12\x03D\x0b\x11\n\
    \x0c\n\x05\x04\x04\x02\x06\x01\x12\x03D\x12\x16\n\x0c\n\x05\x04\x04\x02\
    \x06\x03\x12\x03D\x19\x1a\na\n\x04\x04\x04\x02\x07\x12\x03H\x02\x1d\x1aT\
    \x20whether\x20apply\x20the\x20optimizations\x20to\x20this\x20module,\
    \x20only\x20applicable\x20to\n\x20script\x20modules\n\n\x0c\n\x05\x04\
    \x04\x02\x07\x04\x12\x03H\x02\n\n\x0c\n\x05\x04\x04\x02\x07\x05\x12\x03H\
    \x0b\x0f\n\x0c\n\x05\x04\x04\x02\x07\x01\x12\x03H\x10\x18\n\x0c\n\x05\
    \x04\x04\x02\x07\x03\x12\x03H\x1b\x1c\n\x0b\n\x04\x04\x04\x02\x08\x12\
    \x03J\x02'\n\x0c\n\x05\x04\x04\x02\x08\x04\x12\x03J\x02\n\n\x0c\n\x05\
    \x04\x04\x02\x08\x06\x12\x03J\x0b\x17\n\x0c\n\x05\x04\x04\x02\x08\x01\
    \x12\x03J\x18\"\n\x0c\n\x05\x04\x04\x02\x08\x03\x12\x03J%&\nN\n\x04\x04\
    \x04\x02\t\x12\x03M\x02-\x1aA\x20Used\x20for\x20retrieving\x20module\x20\
    state\x20from\x20the\x20pickled\x20IValues\x20table\n\n\x0c\n\x05\x04\
    \x04\x02\t\x04\x12\x03M\x02\n\n\x0c\n\x05\x04\x04\x02\t\x05\x12\x03M\x0b\
    \x10\n\x0c\n\x05\x04\x04\x02\t\x01\x12\x03M\x11'\n\x0c\n\x05\x04\x04\x02\
    \t\x03\x12\x03M*,\n\x0b\n\x04\x04\x04\x02\n\x12\x03O\x022\n\x0c\n\x05\
    \x04\x04\x02\n\x04\x12\x03O\x02\n\n\x0c\n\x05\x04\x04\x02\n\x06\x12\x03O\
    \x0b\x14\n\x0c\n\x05\x04\x04\x02\n\x01\x12\x03O\x15,\n\x0c\n\x05\x04\x04\
    \x02\n\x03\x12\x03O/1\n\xc8\x01\n\x02\x04\x05\x12\x04U\0W\x01\x1a\xbb\
    \x01\x20Represents\x20all\x20non-module\x20code\x20that\x20the\x20model\
    \x20depends\x20on.\n\x20Right\x20now\x20it's\x20just\x20a\x20straight\
    \x20list\x20of\x20classes,\x20defined\x20in\x20dependency\x20order\n\x20\
    (i.e.\x20dependencies\x20appear\x20before\x20their\x20dependers)\n\n\n\n\
    \x03\x04\x05\x01\x12\x03U\x08\x0e\n\x0b\n\x04\x04\x05\x02\0\x12\x03V\x02\
    +\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03V\x02\n\n\x0c\n\x05\x04\x05\x02\0\
    \x06\x12\x03V\x0b\x14\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03V\x15&\n\x0c\
    \n\x05\x04\x05\x02\0\x03\x12\x03V)*\n\n\n\x02\x05\0\x12\x04Y\0[\x01\n\n\
    \n\x03\x05\0\x01\x12\x03Y\x05\x11\n\x0b\n\x04\x05\0\x02\0\x12\x03Z\x02,\
    \n\x0c\n\x05\x05\0\x02\0\x01\x12\x03Z\x02\x16\n\x0c\n\x05\x05\0\x02\0\
    \x02\x12\x03Z\x19+\n\n\n\x02\x04\x06\x12\x04]\0s\x01\n\n\n\x03\x04\x06\
    \x01\x12\x03]\x08\x10\nJ\n\x03\x04\x06\t\x12\x03_\x02\r\x1a>\x20numbers\
    \x20of\x20fields\x20that\x20have\x20been\x20removed.\x20Do\x20not\x20reu\
    se\x20them!\n\n\x0b\n\x04\x04\x06\t\0\x12\x03_\x0b\x0c\n\x0c\n\x05\x04\
    \x06\t\0\x01\x12\x03_\x0b\x0c\n\x0c\n\x05\x04\x06\t\0\x02\x12\x03_\x0b\
    \x0c\n\n\n\x03\x04\x06\n\x12\x03`\x02\x12\n\x0b\n\x04\x04\x06\n\0\x12\
    \x03`\x0b\x11\n\xdf\x01\n\x04\x04\x06\x02\0\x12\x03e\x02#\x1a\xd1\x01\
    \x20for\x20the\x20proto\x20version,\x20to\x20keep\x20both\x20backward\
    \x20and\x20forward\n\x20compatibility,\x20please\x20bump\x20the\x20proto\
    _version\x20when\x20we\x20add\x20any\n\x20change\x20in\x20the\x20proto.\
    \x20runtime\x20decides\x20whether\x20accept\x20the\n\x20model\x20based\
    \x20on\x20the\x20ir_version.\n\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03e\
    \x02\n\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03e\x0b\x10\n\x0c\n\x05\x04\
    \x06\x02\0\x01\x12\x03e\x11\x1e\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03e!\
    \"\n'\n\x04\x04\x06\x02\x01\x12\x03h\x02%\x1a\x1a\x20main\x20module\x20o\
    f\x20the\x20model\n\n\x0c\n\x05\x04\x06\x02\x01\x04\x12\x03h\x02\n\n\x0c\
    \n\x05\x04\x06\x02\x01\x06\x12\x03h\x0b\x14\n\x0c\n\x05\x04\x06\x02\x01\
    \x01\x12\x03h\x15\x20\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03h#$\n?\n\
    \x04\x04\x06\x02\x02\x12\x03k\x02$\x1a2\x20to\x20distinguish\x20whether\
    \x20exported\x20from\x20c2\x20or\x20torch\n\n\x0c\n\x05\x04\x06\x02\x02\
    \x04\x12\x03k\x02\n\n\x0c\n\x05\x04\x06\x02\x02\x05\x12\x03k\x0b\x11\n\
    \x0c\n\x05\x04\x06\x02\x02\x01\x12\x03k\x12\x1f\n\x0c\n\x05\x04\x06\x02\
    \x02\x03\x12\x03k\"#\n%\n\x04\x04\x06\x02\x03\x12\x03n\x02'\x1a\x18\x20p\
    ut\x20build\x20version\x20here\n\n\x0c\n\x05\x04\x06\x02\x03\x04\x12\x03\
    n\x02\n\n\x0c\n\x05\x04\x06\x02\x03\x05\x12\x03n\x0b\x11\n\x0c\n\x05\x04\
    \x06\x02\x03\x01\x12\x03n\x12\"\n\x0c\n\x05\x04\x06\x02\x03\x03\x12\x03n\
    %&\nj\n\x04\x04\x06\x02\x04\x12\x03r\x02!\x1a]\x20the\x20table\x20contai\
    ns\x20all\x20the\x20tensor\x20information\n\x20the\x20tensor\x20id\x20is\
    \x20defined\x20as\x20TensorProto.name\n\n\x0c\n\x05\x04\x06\x02\x04\x04\
    \x12\x03r\x02\n\n\x0c\n\x05\x04\x06\x02\x04\x06\x12\x03r\x0b\x14\n\x0c\n\
    \x05\x04\x06\x02\x04\x01\x12\x03r\x15\x1c\n\x0c\n\x05\x04\x06\x02\x04\
    \x03\x12\x03r\x1f\x20\
";

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

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

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