tensorflow_serving_client/

meta_graph.rs

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

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

#![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(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `tensorflow/core/protobuf/meta_graph.proto`

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

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

#[derive(PartialEq,Clone,Default)]
pub struct MetaGraphDef {
    // message fields
    pub meta_info_def: ::protobuf::SingularPtrField<MetaGraphDef_MetaInfoDef>,
    pub graph_def: ::protobuf::SingularPtrField<super::graph::GraphDef>,
    pub saver_def: ::protobuf::SingularPtrField<super::saver::SaverDef>,
    pub collection_def: ::std::collections::HashMap<::std::string::String, CollectionDef>,
    pub signature_def: ::std::collections::HashMap<::std::string::String, SignatureDef>,
    pub asset_file_def: ::protobuf::RepeatedField<AssetFileDef>,
    pub object_graph_def: ::protobuf::SingularPtrField<super::saved_object_graph::SavedObjectGraph>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .tensorflow.MetaGraphDef.MetaInfoDef meta_info_def = 1;


    pub fn get_meta_info_def(&self) -> &MetaGraphDef_MetaInfoDef {
        self.meta_info_def.as_ref().unwrap_or_else(|| MetaGraphDef_MetaInfoDef::default_instance())
    }
    pub fn clear_meta_info_def(&mut self) {
        self.meta_info_def.clear();
    }

    pub fn has_meta_info_def(&self) -> bool {
        self.meta_info_def.is_some()
    }

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

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

    // Take field
    pub fn take_meta_info_def(&mut self) -> MetaGraphDef_MetaInfoDef {
        self.meta_info_def.take().unwrap_or_else(|| MetaGraphDef_MetaInfoDef::new())
    }

    // .tensorflow.GraphDef graph_def = 2;


    pub fn get_graph_def(&self) -> &super::graph::GraphDef {
        self.graph_def.as_ref().unwrap_or_else(|| super::graph::GraphDef::default_instance())
    }
    pub fn clear_graph_def(&mut self) {
        self.graph_def.clear();
    }

    pub fn has_graph_def(&self) -> bool {
        self.graph_def.is_some()
    }

    // Param is passed by value, moved
    pub fn set_graph_def(&mut self, v: super::graph::GraphDef) {
        self.graph_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_graph_def(&mut self) -> &mut super::graph::GraphDef {
        if self.graph_def.is_none() {
            self.graph_def.set_default();
        }
        self.graph_def.as_mut().unwrap()
    }

    // Take field
    pub fn take_graph_def(&mut self) -> super::graph::GraphDef {
        self.graph_def.take().unwrap_or_else(|| super::graph::GraphDef::new())
    }

    // .tensorflow.SaverDef saver_def = 3;


    pub fn get_saver_def(&self) -> &super::saver::SaverDef {
        self.saver_def.as_ref().unwrap_or_else(|| super::saver::SaverDef::default_instance())
    }
    pub fn clear_saver_def(&mut self) {
        self.saver_def.clear();
    }

    pub fn has_saver_def(&self) -> bool {
        self.saver_def.is_some()
    }

    // Param is passed by value, moved
    pub fn set_saver_def(&mut self, v: super::saver::SaverDef) {
        self.saver_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_saver_def(&mut self) -> &mut super::saver::SaverDef {
        if self.saver_def.is_none() {
            self.saver_def.set_default();
        }
        self.saver_def.as_mut().unwrap()
    }

    // Take field
    pub fn take_saver_def(&mut self) -> super::saver::SaverDef {
        self.saver_def.take().unwrap_or_else(|| super::saver::SaverDef::new())
    }

    // repeated .tensorflow.MetaGraphDef.CollectionDefEntry collection_def = 4;


    pub fn get_collection_def(&self) -> &::std::collections::HashMap<::std::string::String, CollectionDef> {
        &self.collection_def
    }
    pub fn clear_collection_def(&mut self) {
        self.collection_def.clear();
    }

    // Param is passed by value, moved
    pub fn set_collection_def(&mut self, v: ::std::collections::HashMap<::std::string::String, CollectionDef>) {
        self.collection_def = v;
    }

    // Mutable pointer to the field.
    pub fn mut_collection_def(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, CollectionDef> {
        &mut self.collection_def
    }

    // Take field
    pub fn take_collection_def(&mut self) -> ::std::collections::HashMap<::std::string::String, CollectionDef> {
        ::std::mem::replace(&mut self.collection_def, ::std::collections::HashMap::new())
    }

    // repeated .tensorflow.MetaGraphDef.SignatureDefEntry signature_def = 5;


    pub fn get_signature_def(&self) -> &::std::collections::HashMap<::std::string::String, SignatureDef> {
        &self.signature_def
    }
    pub fn clear_signature_def(&mut self) {
        self.signature_def.clear();
    }

    // Param is passed by value, moved
    pub fn set_signature_def(&mut self, v: ::std::collections::HashMap<::std::string::String, SignatureDef>) {
        self.signature_def = v;
    }

    // Mutable pointer to the field.
    pub fn mut_signature_def(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, SignatureDef> {
        &mut self.signature_def
    }

    // Take field
    pub fn take_signature_def(&mut self) -> ::std::collections::HashMap<::std::string::String, SignatureDef> {
        ::std::mem::replace(&mut self.signature_def, ::std::collections::HashMap::new())
    }

    // repeated .tensorflow.AssetFileDef asset_file_def = 6;


    pub fn get_asset_file_def(&self) -> &[AssetFileDef] {
        &self.asset_file_def
    }
    pub fn clear_asset_file_def(&mut self) {
        self.asset_file_def.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_asset_file_def(&mut self) -> &mut ::protobuf::RepeatedField<AssetFileDef> {
        &mut self.asset_file_def
    }

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

    // .tensorflow.SavedObjectGraph object_graph_def = 7;


    pub fn get_object_graph_def(&self) -> &super::saved_object_graph::SavedObjectGraph {
        self.object_graph_def.as_ref().unwrap_or_else(|| super::saved_object_graph::SavedObjectGraph::default_instance())
    }
    pub fn clear_object_graph_def(&mut self) {
        self.object_graph_def.clear();
    }

    pub fn has_object_graph_def(&self) -> bool {
        self.object_graph_def.is_some()
    }

    // Param is passed by value, moved
    pub fn set_object_graph_def(&mut self, v: super::saved_object_graph::SavedObjectGraph) {
        self.object_graph_def = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_object_graph_def(&mut self) -> &mut super::saved_object_graph::SavedObjectGraph {
        if self.object_graph_def.is_none() {
            self.object_graph_def.set_default();
        }
        self.object_graph_def.as_mut().unwrap()
    }

    // Take field
    pub fn take_object_graph_def(&mut self) -> super::saved_object_graph::SavedObjectGraph {
        self.object_graph_def.take().unwrap_or_else(|| super::saved_object_graph::SavedObjectGraph::new())
    }
}

impl ::protobuf::Message for MetaGraphDef {
    fn is_initialized(&self) -> bool {
        for v in &self.meta_info_def {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.graph_def {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.saver_def {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.asset_file_def {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.object_graph_def {
            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.meta_info_def)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.graph_def)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.saver_def)?;
                },
                4 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(wire_type, is, &mut self.collection_def)?;
                },
                5 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(wire_type, is, &mut self.signature_def)?;
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.asset_file_def)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.object_graph_def)?;
                },
                _ => {
                    ::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.meta_info_def.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.graph_def.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.saver_def.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(4, &self.collection_def);
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(5, &self.signature_def);
        for value in &self.asset_file_def {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.object_graph_def.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.meta_info_def.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)?;
        }
        if let Some(ref v) = self.graph_def.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.saver_def.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(4, &self.collection_def, os)?;
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(5, &self.signature_def, os)?;
        for v in &self.asset_file_def {
            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.object_graph_def.as_ref() {
            os.write_tag(7, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MetaGraphDef_MetaInfoDef>>(
                    "meta_info_def",
                    |m: &MetaGraphDef| { &m.meta_info_def },
                    |m: &mut MetaGraphDef| { &mut m.meta_info_def },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::graph::GraphDef>>(
                    "graph_def",
                    |m: &MetaGraphDef| { &m.graph_def },
                    |m: &mut MetaGraphDef| { &mut m.graph_def },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::saver::SaverDef>>(
                    "saver_def",
                    |m: &MetaGraphDef| { &m.saver_def },
                    |m: &mut MetaGraphDef| { &mut m.saver_def },
                ));
                fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<CollectionDef>>(
                    "collection_def",
                    |m: &MetaGraphDef| { &m.collection_def },
                    |m: &mut MetaGraphDef| { &mut m.collection_def },
                ));
                fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<SignatureDef>>(
                    "signature_def",
                    |m: &MetaGraphDef| { &m.signature_def },
                    |m: &mut MetaGraphDef| { &mut m.signature_def },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<AssetFileDef>>(
                    "asset_file_def",
                    |m: &MetaGraphDef| { &m.asset_file_def },
                    |m: &mut MetaGraphDef| { &mut m.asset_file_def },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::saved_object_graph::SavedObjectGraph>>(
                    "object_graph_def",
                    |m: &MetaGraphDef| { &m.object_graph_def },
                    |m: &mut MetaGraphDef| { &mut m.object_graph_def },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<MetaGraphDef>(
                    "MetaGraphDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static MetaGraphDef {
        static mut instance: ::protobuf::lazy::Lazy<MetaGraphDef> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(MetaGraphDef::new)
        }
    }
}

impl ::protobuf::Clear for MetaGraphDef {
    fn clear(&mut self) {
        self.meta_info_def.clear();
        self.graph_def.clear();
        self.saver_def.clear();
        self.collection_def.clear();
        self.signature_def.clear();
        self.asset_file_def.clear();
        self.object_graph_def.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct MetaGraphDef_MetaInfoDef {
    // message fields
    pub meta_graph_version: ::std::string::String,
    pub stripped_op_list: ::protobuf::SingularPtrField<super::op_def::OpList>,
    pub any_info: ::protobuf::SingularPtrField<::protobuf::well_known_types::Any>,
    pub tags: ::protobuf::RepeatedField<::std::string::String>,
    pub tensorflow_version: ::std::string::String,
    pub tensorflow_git_version: ::std::string::String,
    pub stripped_default_attrs: bool,
    pub function_aliases: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string meta_graph_version = 1;


    pub fn get_meta_graph_version(&self) -> &str {
        &self.meta_graph_version
    }
    pub fn clear_meta_graph_version(&mut self) {
        self.meta_graph_version.clear();
    }

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

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

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

    // .tensorflow.OpList stripped_op_list = 2;


    pub fn get_stripped_op_list(&self) -> &super::op_def::OpList {
        self.stripped_op_list.as_ref().unwrap_or_else(|| super::op_def::OpList::default_instance())
    }
    pub fn clear_stripped_op_list(&mut self) {
        self.stripped_op_list.clear();
    }

    pub fn has_stripped_op_list(&self) -> bool {
        self.stripped_op_list.is_some()
    }

    // Param is passed by value, moved
    pub fn set_stripped_op_list(&mut self, v: super::op_def::OpList) {
        self.stripped_op_list = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_stripped_op_list(&mut self) -> &mut super::op_def::OpList {
        if self.stripped_op_list.is_none() {
            self.stripped_op_list.set_default();
        }
        self.stripped_op_list.as_mut().unwrap()
    }

    // Take field
    pub fn take_stripped_op_list(&mut self) -> super::op_def::OpList {
        self.stripped_op_list.take().unwrap_or_else(|| super::op_def::OpList::new())
    }

    // .google.protobuf.Any any_info = 3;


    pub fn get_any_info(&self) -> &::protobuf::well_known_types::Any {
        self.any_info.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Any::default_instance())
    }
    pub fn clear_any_info(&mut self) {
        self.any_info.clear();
    }

    pub fn has_any_info(&self) -> bool {
        self.any_info.is_some()
    }

    // Param is passed by value, moved
    pub fn set_any_info(&mut self, v: ::protobuf::well_known_types::Any) {
        self.any_info = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_any_info(&mut self) -> &mut ::protobuf::well_known_types::Any {
        if self.any_info.is_none() {
            self.any_info.set_default();
        }
        self.any_info.as_mut().unwrap()
    }

    // Take field
    pub fn take_any_info(&mut self) -> ::protobuf::well_known_types::Any {
        self.any_info.take().unwrap_or_else(|| ::protobuf::well_known_types::Any::new())
    }

    // repeated string tags = 4;


    pub fn get_tags(&self) -> &[::std::string::String] {
        &self.tags
    }
    pub fn clear_tags(&mut self) {
        self.tags.clear();
    }

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

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

    // Take field
    pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
    }

    // string tensorflow_version = 5;


    pub fn get_tensorflow_version(&self) -> &str {
        &self.tensorflow_version
    }
    pub fn clear_tensorflow_version(&mut self) {
        self.tensorflow_version.clear();
    }

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

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

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

    // string tensorflow_git_version = 6;


    pub fn get_tensorflow_git_version(&self) -> &str {
        &self.tensorflow_git_version
    }
    pub fn clear_tensorflow_git_version(&mut self) {
        self.tensorflow_git_version.clear();
    }

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

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

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

    // bool stripped_default_attrs = 7;


    pub fn get_stripped_default_attrs(&self) -> bool {
        self.stripped_default_attrs
    }
    pub fn clear_stripped_default_attrs(&mut self) {
        self.stripped_default_attrs = false;
    }

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

    // repeated .tensorflow.MetaGraphDef.MetaInfoDef.FunctionAliasesEntry function_aliases = 8;


    pub fn get_function_aliases(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.function_aliases
    }
    pub fn clear_function_aliases(&mut self) {
        self.function_aliases.clear();
    }

    // Param is passed by value, moved
    pub fn set_function_aliases(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
        self.function_aliases = v;
    }

    // Mutable pointer to the field.
    pub fn mut_function_aliases(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.function_aliases
    }

    // Take field
    pub fn take_function_aliases(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.function_aliases, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for MetaGraphDef_MetaInfoDef {
    fn is_initialized(&self) -> bool {
        for v in &self.stripped_op_list {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.any_info {
            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_proto3_string_into(wire_type, is, &mut self.meta_graph_version)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stripped_op_list)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.any_info)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tensorflow_version)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tensorflow_git_version)?;
                },
                7 => {
                    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.stripped_default_attrs = tmp;
                },
                8 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.function_aliases)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.meta_graph_version.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.meta_graph_version);
        }
        if let Some(ref v) = self.stripped_op_list.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.any_info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.tags {
            my_size += ::protobuf::rt::string_size(4, &value);
        };
        if !self.tensorflow_version.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.tensorflow_version);
        }
        if !self.tensorflow_git_version.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.tensorflow_git_version);
        }
        if self.stripped_default_attrs != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(8, &self.function_aliases);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.meta_graph_version.is_empty() {
            os.write_string(1, &self.meta_graph_version)?;
        }
        if let Some(ref v) = self.stripped_op_list.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.any_info.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.tags {
            os.write_string(4, &v)?;
        };
        if !self.tensorflow_version.is_empty() {
            os.write_string(5, &self.tensorflow_version)?;
        }
        if !self.tensorflow_git_version.is_empty() {
            os.write_string(6, &self.tensorflow_git_version)?;
        }
        if self.stripped_default_attrs != false {
            os.write_bool(7, self.stripped_default_attrs)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(8, &self.function_aliases, 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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "meta_graph_version",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.meta_graph_version },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.meta_graph_version },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::op_def::OpList>>(
                    "stripped_op_list",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.stripped_op_list },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.stripped_op_list },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>(
                    "any_info",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.any_info },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.any_info },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tags",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.tags },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.tags },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tensorflow_version",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.tensorflow_version },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.tensorflow_version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tensorflow_git_version",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.tensorflow_git_version },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.tensorflow_git_version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "stripped_default_attrs",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.stripped_default_attrs },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.stripped_default_attrs },
                ));
                fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
                    "function_aliases",
                    |m: &MetaGraphDef_MetaInfoDef| { &m.function_aliases },
                    |m: &mut MetaGraphDef_MetaInfoDef| { &mut m.function_aliases },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<MetaGraphDef_MetaInfoDef>(
                    "MetaGraphDef.MetaInfoDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static MetaGraphDef_MetaInfoDef {
        static mut instance: ::protobuf::lazy::Lazy<MetaGraphDef_MetaInfoDef> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(MetaGraphDef_MetaInfoDef::new)
        }
    }
}

impl ::protobuf::Clear for MetaGraphDef_MetaInfoDef {
    fn clear(&mut self) {
        self.meta_graph_version.clear();
        self.stripped_op_list.clear();
        self.any_info.clear();
        self.tags.clear();
        self.tensorflow_version.clear();
        self.tensorflow_git_version.clear();
        self.stripped_default_attrs = false;
        self.function_aliases.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef {
    // message oneof groups
    pub kind: ::std::option::Option<CollectionDef_oneof_kind>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum CollectionDef_oneof_kind {
    node_list(CollectionDef_NodeList),
    bytes_list(CollectionDef_BytesList),
    int64_list(CollectionDef_Int64List),
    float_list(CollectionDef_FloatList),
    any_list(CollectionDef_AnyList),
}

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

    // .tensorflow.CollectionDef.NodeList node_list = 1;


    pub fn get_node_list(&self) -> &CollectionDef_NodeList {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(ref v)) => v,
            _ => CollectionDef_NodeList::default_instance(),
        }
    }
    pub fn clear_node_list(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_node_list(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_node_list(&mut self, v: CollectionDef_NodeList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(v))
    }

    // Mutable pointer to the field.
    pub fn mut_node_list(&mut self) -> &mut CollectionDef_NodeList {
        if let ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(CollectionDef_NodeList::new()));
        }
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_node_list(&mut self) -> CollectionDef_NodeList {
        if self.has_node_list() {
            match self.kind.take() {
                ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(v)) => v,
                _ => panic!(),
            }
        } else {
            CollectionDef_NodeList::new()
        }
    }

    // .tensorflow.CollectionDef.BytesList bytes_list = 2;


    pub fn get_bytes_list(&self) -> &CollectionDef_BytesList {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(ref v)) => v,
            _ => CollectionDef_BytesList::default_instance(),
        }
    }
    pub fn clear_bytes_list(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_bytes_list(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bytes_list(&mut self, v: CollectionDef_BytesList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bytes_list(&mut self) -> &mut CollectionDef_BytesList {
        if let ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(CollectionDef_BytesList::new()));
        }
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bytes_list(&mut self) -> CollectionDef_BytesList {
        if self.has_bytes_list() {
            match self.kind.take() {
                ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(v)) => v,
                _ => panic!(),
            }
        } else {
            CollectionDef_BytesList::new()
        }
    }

    // .tensorflow.CollectionDef.Int64List int64_list = 3;


    pub fn get_int64_list(&self) -> &CollectionDef_Int64List {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(ref v)) => v,
            _ => CollectionDef_Int64List::default_instance(),
        }
    }
    pub fn clear_int64_list(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_int64_list(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int64_list(&mut self, v: CollectionDef_Int64List) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(v))
    }

    // Mutable pointer to the field.
    pub fn mut_int64_list(&mut self) -> &mut CollectionDef_Int64List {
        if let ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(CollectionDef_Int64List::new()));
        }
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_int64_list(&mut self) -> CollectionDef_Int64List {
        if self.has_int64_list() {
            match self.kind.take() {
                ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(v)) => v,
                _ => panic!(),
            }
        } else {
            CollectionDef_Int64List::new()
        }
    }

    // .tensorflow.CollectionDef.FloatList float_list = 4;


    pub fn get_float_list(&self) -> &CollectionDef_FloatList {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(ref v)) => v,
            _ => CollectionDef_FloatList::default_instance(),
        }
    }
    pub fn clear_float_list(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_float_list(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_float_list(&mut self, v: CollectionDef_FloatList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(v))
    }

    // Mutable pointer to the field.
    pub fn mut_float_list(&mut self) -> &mut CollectionDef_FloatList {
        if let ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(CollectionDef_FloatList::new()));
        }
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_float_list(&mut self) -> CollectionDef_FloatList {
        if self.has_float_list() {
            match self.kind.take() {
                ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(v)) => v,
                _ => panic!(),
            }
        } else {
            CollectionDef_FloatList::new()
        }
    }

    // .tensorflow.CollectionDef.AnyList any_list = 5;


    pub fn get_any_list(&self) -> &CollectionDef_AnyList {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(ref v)) => v,
            _ => CollectionDef_AnyList::default_instance(),
        }
    }
    pub fn clear_any_list(&mut self) {
        self.kind = ::std::option::Option::None;
    }

    pub fn has_any_list(&self) -> bool {
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_any_list(&mut self, v: CollectionDef_AnyList) {
        self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(v))
    }

    // Mutable pointer to the field.
    pub fn mut_any_list(&mut self) -> &mut CollectionDef_AnyList {
        if let ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(_)) = self.kind {
        } else {
            self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(CollectionDef_AnyList::new()));
        }
        match self.kind {
            ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_any_list(&mut self) -> CollectionDef_AnyList {
        if self.has_any_list() {
            match self.kind.take() {
                ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(v)) => v,
                _ => panic!(),
            }
        } else {
            CollectionDef_AnyList::new()
        }
    }
}

impl ::protobuf::Message for CollectionDef {
    fn is_initialized(&self) -> bool {
        if let Some(CollectionDef_oneof_kind::node_list(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CollectionDef_oneof_kind::bytes_list(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CollectionDef_oneof_kind::int64_list(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CollectionDef_oneof_kind::float_list(ref v)) = self.kind {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(CollectionDef_oneof_kind::any_list(ref v)) = self.kind {
            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::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::node_list(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::bytes_list(is.read_message()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::int64_list(is.read_message()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::float_list(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.kind = ::std::option::Option::Some(CollectionDef_oneof_kind::any_list(is.read_message()?));
                },
                _ => {
                    ::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 ::std::option::Option::Some(ref v) = self.kind {
            match v {
                &CollectionDef_oneof_kind::node_list(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CollectionDef_oneof_kind::bytes_list(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CollectionDef_oneof_kind::int64_list(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CollectionDef_oneof_kind::float_list(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &CollectionDef_oneof_kind::any_list(ref v) => {
                    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 ::std::option::Option::Some(ref v) = self.kind {
            match v {
                &CollectionDef_oneof_kind::node_list(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CollectionDef_oneof_kind::bytes_list(ref v) => {
                    os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CollectionDef_oneof_kind::int64_list(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CollectionDef_oneof_kind::float_list(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &CollectionDef_oneof_kind::any_list(ref v) => {
                    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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_NodeList>(
                    "node_list",
                    CollectionDef::has_node_list,
                    CollectionDef::get_node_list,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_BytesList>(
                    "bytes_list",
                    CollectionDef::has_bytes_list,
                    CollectionDef::get_bytes_list,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_Int64List>(
                    "int64_list",
                    CollectionDef::has_int64_list,
                    CollectionDef::get_int64_list,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_FloatList>(
                    "float_list",
                    CollectionDef::has_float_list,
                    CollectionDef::get_float_list,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CollectionDef_AnyList>(
                    "any_list",
                    CollectionDef::has_any_list,
                    CollectionDef::get_any_list,
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef>(
                    "CollectionDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CollectionDef {
        static mut instance: ::protobuf::lazy::Lazy<CollectionDef> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(CollectionDef::new)
        }
    }
}

impl ::protobuf::Clear for CollectionDef {
    fn clear(&mut self) {
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.kind = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // repeated string value = 1;


    pub fn get_value(&self) -> &[::std::string::String] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

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

    // Take field
    pub fn take_value(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CollectionDef_NodeList {
    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_repeated_string_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::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.value {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        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.value {
            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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "value",
                    |m: &CollectionDef_NodeList| { &m.value },
                    |m: &mut CollectionDef_NodeList| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_NodeList>(
                    "CollectionDef.NodeList",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CollectionDef_NodeList {
        static mut instance: ::protobuf::lazy::Lazy<CollectionDef_NodeList> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(CollectionDef_NodeList::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_BytesList {
    // message fields
    pub value: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated bytes value = 1;


    pub fn get_value(&self) -> &[::std::vec::Vec<u8>] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        &mut self.value
    }

    // Take field
    pub fn take_value(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
        ::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CollectionDef_BytesList {
    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_repeated_bytes_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::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.value {
            my_size += ::protobuf::rt::bytes_size(1, &value);
        };
        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.value {
            os.write_bytes(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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "value",
                    |m: &CollectionDef_BytesList| { &m.value },
                    |m: &mut CollectionDef_BytesList| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_BytesList>(
                    "CollectionDef.BytesList",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CollectionDef_BytesList {
        static mut instance: ::protobuf::lazy::Lazy<CollectionDef_BytesList> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(CollectionDef_BytesList::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_Int64List {
    // message fields
    pub value: ::std::vec::Vec<i64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated int64 value = 1;


    pub fn get_value(&self) -> &[i64] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

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

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

impl ::protobuf::Message for CollectionDef_Int64List {
    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_repeated_int64_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.value.is_empty() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            // TODO: Data size is computed again, it should be cached
            os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.value))?;
            for v in &self.value {
                os.write_int64_no_tag(*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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "value",
                    |m: &CollectionDef_Int64List| { &m.value },
                    |m: &mut CollectionDef_Int64List| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_Int64List>(
                    "CollectionDef.Int64List",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CollectionDef_Int64List {
        static mut instance: ::protobuf::lazy::Lazy<CollectionDef_Int64List> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(CollectionDef_Int64List::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_FloatList {
    // message fields
    pub value: ::std::vec::Vec<f32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated float value = 1;


    pub fn get_value(&self) -> &[f32] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<f32> {
        &mut self.value
    }

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

impl ::protobuf::Message for CollectionDef_FloatList {
    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_repeated_float_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.value.is_empty() {
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size((self.value.len() * 4) as u32) + (self.value.len() * 4) as u32;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.value.is_empty() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            // TODO: Data size is computed again, it should be cached
            os.write_raw_varint32((self.value.len() * 4) as u32)?;
            for v in &self.value {
                os.write_float_no_tag(*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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
                    "value",
                    |m: &CollectionDef_FloatList| { &m.value },
                    |m: &mut CollectionDef_FloatList| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_FloatList>(
                    "CollectionDef.FloatList",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CollectionDef_FloatList {
        static mut instance: ::protobuf::lazy::Lazy<CollectionDef_FloatList> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(CollectionDef_FloatList::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CollectionDef_AnyList {
    // message fields
    pub value: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .google.protobuf.Any value = 1;


    pub fn get_value(&self) -> &[::protobuf::well_known_types::Any] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

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

    // Take field
    pub fn take_value(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Any> {
        ::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::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.value)?;
                },
                _ => {
                    ::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.value {
            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<()> {
        for v in &self.value {
            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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>(
                    "value",
                    |m: &CollectionDef_AnyList| { &m.value },
                    |m: &mut CollectionDef_AnyList| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<CollectionDef_AnyList>(
                    "CollectionDef.AnyList",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CollectionDef_AnyList {
        static mut instance: ::protobuf::lazy::Lazy<CollectionDef_AnyList> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(CollectionDef_AnyList::new)
        }
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TensorInfo {
    // message fields
    pub dtype: super::types::DataType,
    pub tensor_shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
    // message oneof groups
    pub encoding: ::std::option::Option<TensorInfo_oneof_encoding>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum TensorInfo_oneof_encoding {
    name(::std::string::String),
    coo_sparse(TensorInfo_CooSparse),
    composite_tensor(TensorInfo_CompositeTensor),
}

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::name(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_name(&mut self) {
        self.encoding = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::name(..)) => true,
            _ => false,
        }
    }

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

    // Mutable pointer to the field.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(TensorInfo_oneof_encoding::name(_)) = self.encoding {
        } else {
            self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::name(::std::string::String::new()));
        }
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::name(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        if self.has_name() {
            match self.encoding.take() {
                ::std::option::Option::Some(TensorInfo_oneof_encoding::name(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // .tensorflow.TensorInfo.CooSparse coo_sparse = 4;


    pub fn get_coo_sparse(&self) -> &TensorInfo_CooSparse {
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(ref v)) => v,
            _ => TensorInfo_CooSparse::default_instance(),
        }
    }
    pub fn clear_coo_sparse(&mut self) {
        self.encoding = ::std::option::Option::None;
    }

    pub fn has_coo_sparse(&self) -> bool {
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_coo_sparse(&mut self, v: TensorInfo_CooSparse) {
        self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(v))
    }

    // Mutable pointer to the field.
    pub fn mut_coo_sparse(&mut self) -> &mut TensorInfo_CooSparse {
        if let ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(_)) = self.encoding {
        } else {
            self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(TensorInfo_CooSparse::new()));
        }
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_coo_sparse(&mut self) -> TensorInfo_CooSparse {
        if self.has_coo_sparse() {
            match self.encoding.take() {
                ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(v)) => v,
                _ => panic!(),
            }
        } else {
            TensorInfo_CooSparse::new()
        }
    }

    // .tensorflow.TensorInfo.CompositeTensor composite_tensor = 5;


    pub fn get_composite_tensor(&self) -> &TensorInfo_CompositeTensor {
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(ref v)) => v,
            _ => TensorInfo_CompositeTensor::default_instance(),
        }
    }
    pub fn clear_composite_tensor(&mut self) {
        self.encoding = ::std::option::Option::None;
    }

    pub fn has_composite_tensor(&self) -> bool {
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_composite_tensor(&mut self, v: TensorInfo_CompositeTensor) {
        self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(v))
    }

    // Mutable pointer to the field.
    pub fn mut_composite_tensor(&mut self) -> &mut TensorInfo_CompositeTensor {
        if let ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(_)) = self.encoding {
        } else {
            self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(TensorInfo_CompositeTensor::new()));
        }
        match self.encoding {
            ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_composite_tensor(&mut self) -> TensorInfo_CompositeTensor {
        if self.has_composite_tensor() {
            match self.encoding.take() {
                ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(v)) => v,
                _ => panic!(),
            }
        } else {
            TensorInfo_CompositeTensor::new()
        }
    }

    // .tensorflow.DataType dtype = 2;


    pub fn get_dtype(&self) -> super::types::DataType {
        self.dtype
    }
    pub fn clear_dtype(&mut self) {
        self.dtype = super::types::DataType::DT_INVALID;
    }

    // Param is passed by value, moved
    pub fn set_dtype(&mut self, v: super::types::DataType) {
        self.dtype = v;
    }

    // .tensorflow.TensorShapeProto tensor_shape = 3;


    pub fn get_tensor_shape(&self) -> &super::tensor_shape::TensorShapeProto {
        self.tensor_shape.as_ref().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::default_instance())
    }
    pub fn clear_tensor_shape(&mut self) {
        self.tensor_shape.clear();
    }

    pub fn has_tensor_shape(&self) -> bool {
        self.tensor_shape.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tensor_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
        self.tensor_shape = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_tensor_shape(&mut self) -> super::tensor_shape::TensorShapeProto {
        self.tensor_shape.take().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::new())
    }
}

impl ::protobuf::Message for TensorInfo {
    fn is_initialized(&self) -> bool {
        if let Some(TensorInfo_oneof_encoding::coo_sparse(ref v)) = self.encoding {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(TensorInfo_oneof_encoding::composite_tensor(ref v)) = self.encoding {
            if !v.is_initialized() {
                return false;
            }
        }
        for v in &self.tensor_shape {
            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::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::name(is.read_string()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::coo_sparse(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.encoding = ::std::option::Option::Some(TensorInfo_oneof_encoding::composite_tensor(is.read_message()?));
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dtype, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.tensor_shape)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.dtype != super::types::DataType::DT_INVALID {
            my_size += ::protobuf::rt::enum_size(2, self.dtype);
        }
        if let Some(ref v) = self.tensor_shape.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let ::std::option::Option::Some(ref v) = self.encoding {
            match v {
                &TensorInfo_oneof_encoding::name(ref v) => {
                    my_size += ::protobuf::rt::string_size(1, &v);
                },
                &TensorInfo_oneof_encoding::coo_sparse(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &TensorInfo_oneof_encoding::composite_tensor(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.dtype != super::types::DataType::DT_INVALID {
            os.write_enum(2, self.dtype.value())?;
        }
        if let Some(ref v) = self.tensor_shape.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let ::std::option::Option::Some(ref v) = self.encoding {
            match v {
                &TensorInfo_oneof_encoding::name(ref v) => {
                    os.write_string(1, v)?;
                },
                &TensorInfo_oneof_encoding::coo_sparse(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &TensorInfo_oneof_encoding::composite_tensor(ref v) => {
                    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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                    "name",
                    TensorInfo::has_name,
                    TensorInfo::get_name,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TensorInfo_CooSparse>(
                    "coo_sparse",
                    TensorInfo::has_coo_sparse,
                    TensorInfo::get_coo_sparse,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TensorInfo_CompositeTensor>(
                    "composite_tensor",
                    TensorInfo::has_composite_tensor,
                    TensorInfo::get_composite_tensor,
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::types::DataType>>(
                    "dtype",
                    |m: &TensorInfo| { &m.dtype },
                    |m: &mut TensorInfo| { &mut m.dtype },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_shape::TensorShapeProto>>(
                    "tensor_shape",
                    |m: &TensorInfo| { &m.tensor_shape },
                    |m: &mut TensorInfo| { &mut m.tensor_shape },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorInfo>(
                    "TensorInfo",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TensorInfo {
        static mut instance: ::protobuf::lazy::Lazy<TensorInfo> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(TensorInfo::new)
        }
    }
}

impl ::protobuf::Clear for TensorInfo {
    fn clear(&mut self) {
        self.encoding = ::std::option::Option::None;
        self.encoding = ::std::option::Option::None;
        self.encoding = ::std::option::Option::None;
        self.dtype = super::types::DataType::DT_INVALID;
        self.tensor_shape.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TensorInfo_CooSparse {
    // message fields
    pub values_tensor_name: ::std::string::String,
    pub indices_tensor_name: ::std::string::String,
    pub dense_shape_tensor_name: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string values_tensor_name = 1;


    pub fn get_values_tensor_name(&self) -> &str {
        &self.values_tensor_name
    }
    pub fn clear_values_tensor_name(&mut self) {
        self.values_tensor_name.clear();
    }

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

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

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

    // string indices_tensor_name = 2;


    pub fn get_indices_tensor_name(&self) -> &str {
        &self.indices_tensor_name
    }
    pub fn clear_indices_tensor_name(&mut self) {
        self.indices_tensor_name.clear();
    }

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

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

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

    // string dense_shape_tensor_name = 3;


    pub fn get_dense_shape_tensor_name(&self) -> &str {
        &self.dense_shape_tensor_name
    }
    pub fn clear_dense_shape_tensor_name(&mut self) {
        self.dense_shape_tensor_name.clear();
    }

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

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

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

impl ::protobuf::Message for TensorInfo_CooSparse {
    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_proto3_string_into(wire_type, is, &mut self.values_tensor_name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.indices_tensor_name)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.dense_shape_tensor_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 !self.values_tensor_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.values_tensor_name);
        }
        if !self.indices_tensor_name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.indices_tensor_name);
        }
        if !self.dense_shape_tensor_name.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.dense_shape_tensor_name);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.values_tensor_name.is_empty() {
            os.write_string(1, &self.values_tensor_name)?;
        }
        if !self.indices_tensor_name.is_empty() {
            os.write_string(2, &self.indices_tensor_name)?;
        }
        if !self.dense_shape_tensor_name.is_empty() {
            os.write_string(3, &self.dense_shape_tensor_name)?;
        }
        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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "values_tensor_name",
                    |m: &TensorInfo_CooSparse| { &m.values_tensor_name },
                    |m: &mut TensorInfo_CooSparse| { &mut m.values_tensor_name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "indices_tensor_name",
                    |m: &TensorInfo_CooSparse| { &m.indices_tensor_name },
                    |m: &mut TensorInfo_CooSparse| { &mut m.indices_tensor_name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "dense_shape_tensor_name",
                    |m: &TensorInfo_CooSparse| { &m.dense_shape_tensor_name },
                    |m: &mut TensorInfo_CooSparse| { &mut m.dense_shape_tensor_name },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorInfo_CooSparse>(
                    "TensorInfo.CooSparse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TensorInfo_CooSparse {
        static mut instance: ::protobuf::lazy::Lazy<TensorInfo_CooSparse> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(TensorInfo_CooSparse::new)
        }
    }
}

impl ::protobuf::Clear for TensorInfo_CooSparse {
    fn clear(&mut self) {
        self.values_tensor_name.clear();
        self.indices_tensor_name.clear();
        self.dense_shape_tensor_name.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct TensorInfo_CompositeTensor {
    // message fields
    pub type_spec: ::protobuf::SingularPtrField<super::struct_pb::TypeSpecProto>,
    pub components: ::protobuf::RepeatedField<TensorInfo>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .tensorflow.TypeSpecProto type_spec = 1;


    pub fn get_type_spec(&self) -> &super::struct_pb::TypeSpecProto {
        self.type_spec.as_ref().unwrap_or_else(|| super::struct_pb::TypeSpecProto::default_instance())
    }
    pub fn clear_type_spec(&mut self) {
        self.type_spec.clear();
    }

    pub fn has_type_spec(&self) -> bool {
        self.type_spec.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type_spec(&mut self, v: super::struct_pb::TypeSpecProto) {
        self.type_spec = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_type_spec(&mut self) -> &mut super::struct_pb::TypeSpecProto {
        if self.type_spec.is_none() {
            self.type_spec.set_default();
        }
        self.type_spec.as_mut().unwrap()
    }

    // Take field
    pub fn take_type_spec(&mut self) -> super::struct_pb::TypeSpecProto {
        self.type_spec.take().unwrap_or_else(|| super::struct_pb::TypeSpecProto::new())
    }

    // repeated .tensorflow.TensorInfo components = 2;


    pub fn get_components(&self) -> &[TensorInfo] {
        &self.components
    }
    pub fn clear_components(&mut self) {
        self.components.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_components(&mut self) -> &mut ::protobuf::RepeatedField<TensorInfo> {
        &mut self.components
    }

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

impl ::protobuf::Message for TensorInfo_CompositeTensor {
    fn is_initialized(&self) -> bool {
        for v in &self.type_spec {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.components {
            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.type_spec)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.components)?;
                },
                _ => {
                    ::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.type_spec.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.components {
            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(ref v) = self.type_spec.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)?;
        }
        for v in &self.components {
            os.write_tag(2, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::struct_pb::TypeSpecProto>>(
                    "type_spec",
                    |m: &TensorInfo_CompositeTensor| { &m.type_spec },
                    |m: &mut TensorInfo_CompositeTensor| { &mut m.type_spec },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
                    "components",
                    |m: &TensorInfo_CompositeTensor| { &m.components },
                    |m: &mut TensorInfo_CompositeTensor| { &mut m.components },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorInfo_CompositeTensor>(
                    "TensorInfo.CompositeTensor",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TensorInfo_CompositeTensor {
        static mut instance: ::protobuf::lazy::Lazy<TensorInfo_CompositeTensor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(TensorInfo_CompositeTensor::new)
        }
    }
}

impl ::protobuf::Clear for TensorInfo_CompositeTensor {
    fn clear(&mut self) {
        self.type_spec.clear();
        self.components.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SignatureDef {
    // message fields
    pub inputs: ::std::collections::HashMap<::std::string::String, TensorInfo>,
    pub outputs: ::std::collections::HashMap<::std::string::String, TensorInfo>,
    pub method_name: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .tensorflow.SignatureDef.InputsEntry inputs = 1;


    pub fn get_inputs(&self) -> &::std::collections::HashMap<::std::string::String, TensorInfo> {
        &self.inputs
    }
    pub fn clear_inputs(&mut self) {
        self.inputs.clear();
    }

    // Param is passed by value, moved
    pub fn set_inputs(&mut self, v: ::std::collections::HashMap<::std::string::String, TensorInfo>) {
        self.inputs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_inputs(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, TensorInfo> {
        &mut self.inputs
    }

    // Take field
    pub fn take_inputs(&mut self) -> ::std::collections::HashMap<::std::string::String, TensorInfo> {
        ::std::mem::replace(&mut self.inputs, ::std::collections::HashMap::new())
    }

    // repeated .tensorflow.SignatureDef.OutputsEntry outputs = 2;


    pub fn get_outputs(&self) -> &::std::collections::HashMap<::std::string::String, TensorInfo> {
        &self.outputs
    }
    pub fn clear_outputs(&mut self) {
        self.outputs.clear();
    }

    // Param is passed by value, moved
    pub fn set_outputs(&mut self, v: ::std::collections::HashMap<::std::string::String, TensorInfo>) {
        self.outputs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_outputs(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, TensorInfo> {
        &mut self.outputs
    }

    // Take field
    pub fn take_outputs(&mut self) -> ::std::collections::HashMap<::std::string::String, TensorInfo> {
        ::std::mem::replace(&mut self.outputs, ::std::collections::HashMap::new())
    }

    // string method_name = 3;


    pub fn get_method_name(&self) -> &str {
        &self.method_name
    }
    pub fn clear_method_name(&mut self) {
        self.method_name.clear();
    }

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

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

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

impl ::protobuf::Message for SignatureDef {
    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_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(wire_type, is, &mut self.inputs)?;
                },
                2 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(wire_type, is, &mut self.outputs)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.method_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;
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(1, &self.inputs);
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(2, &self.outputs);
        if !self.method_name.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.method_name);
        }
        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<()> {
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(1, &self.inputs, os)?;
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(2, &self.outputs, os)?;
        if !self.method_name.is_empty() {
            os.write_string(3, &self.method_name)?;
        }
        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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
                    "inputs",
                    |m: &SignatureDef| { &m.inputs },
                    |m: &mut SignatureDef| { &mut m.inputs },
                ));
                fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
                    "outputs",
                    |m: &SignatureDef| { &m.outputs },
                    |m: &mut SignatureDef| { &mut m.outputs },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "method_name",
                    |m: &SignatureDef| { &m.method_name },
                    |m: &mut SignatureDef| { &mut m.method_name },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<SignatureDef>(
                    "SignatureDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static SignatureDef {
        static mut instance: ::protobuf::lazy::Lazy<SignatureDef> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(SignatureDef::new)
        }
    }
}

impl ::protobuf::Clear for SignatureDef {
    fn clear(&mut self) {
        self.inputs.clear();
        self.outputs.clear();
        self.method_name.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct AssetFileDef {
    // message fields
    pub tensor_info: ::protobuf::SingularPtrField<TensorInfo>,
    pub filename: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .tensorflow.TensorInfo tensor_info = 1;


    pub fn get_tensor_info(&self) -> &TensorInfo {
        self.tensor_info.as_ref().unwrap_or_else(|| TensorInfo::default_instance())
    }
    pub fn clear_tensor_info(&mut self) {
        self.tensor_info.clear();
    }

    pub fn has_tensor_info(&self) -> bool {
        self.tensor_info.is_some()
    }

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

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

    // Take field
    pub fn take_tensor_info(&mut self) -> TensorInfo {
        self.tensor_info.take().unwrap_or_else(|| TensorInfo::new())
    }

    // string filename = 2;


    pub fn get_filename(&self) -> &str {
        &self.filename
    }
    pub fn clear_filename(&mut self) {
        self.filename.clear();
    }

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

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

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

impl ::protobuf::Message for AssetFileDef {
    fn is_initialized(&self) -> bool {
        for v in &self.tensor_info {
            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.tensor_info)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filename)?;
                },
                _ => {
                    ::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.tensor_info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.filename.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.filename);
        }
        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.tensor_info.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)?;
        }
        if !self.filename.is_empty() {
            os.write_string(2, &self.filename)?;
        }
        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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TensorInfo>>(
                    "tensor_info",
                    |m: &AssetFileDef| { &m.tensor_info },
                    |m: &mut AssetFileDef| { &mut m.tensor_info },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "filename",
                    |m: &AssetFileDef| { &m.filename },
                    |m: &mut AssetFileDef| { &mut m.filename },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<AssetFileDef>(
                    "AssetFileDef",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static AssetFileDef {
        static mut instance: ::protobuf::lazy::Lazy<AssetFileDef> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(AssetFileDef::new)
        }
    }
}

impl ::protobuf::Clear for AssetFileDef {
    fn clear(&mut self) {
        self.tensor_info.clear();
        self.filename.clear();
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n)tensorflow/core/protobuf/meta_graph.proto\x12\ntensorflow\x1a\x19goog\
    le/protobuf/any.proto\x1a%tensorflow/core/framework/graph.proto\x1a&tens\
    orflow/core/framework/op_def.proto\x1a,tensorflow/core/framework/tensor_\
    shape.proto\x1a%tensorflow/core/framework/types.proto\x1a1tensorflow/cor\
    e/protobuf/saved_object_graph.proto\x1a$tensorflow/core/protobuf/saver.p\
    roto\x1a%tensorflow/core/protobuf/struct.proto\"\xa9\t\n\x0cMetaGraphDef\
    \x12H\n\rmeta_info_def\x18\x01\x20\x01(\x0b2$.tensorflow.MetaGraphDef.Me\
    taInfoDefR\x0bmetaInfoDef\x121\n\tgraph_def\x18\x02\x20\x01(\x0b2\x14.te\
    nsorflow.GraphDefR\x08graphDef\x121\n\tsaver_def\x18\x03\x20\x01(\x0b2\
    \x14.tensorflow.SaverDefR\x08saverDef\x12R\n\x0ecollection_def\x18\x04\
    \x20\x03(\x0b2+.tensorflow.MetaGraphDef.CollectionDefEntryR\rcollectionD\
    ef\x12O\n\rsignature_def\x18\x05\x20\x03(\x0b2*.tensorflow.MetaGraphDef.\
    SignatureDefEntryR\x0csignatureDef\x12>\n\x0easset_file_def\x18\x06\x20\
    \x03(\x0b2\x18.tensorflow.AssetFileDefR\x0cassetFileDef\x12F\n\x10object\
    _graph_def\x18\x07\x20\x01(\x0b2\x1c.tensorflow.SavedObjectGraphR\x0eobj\
    ectGraphDef\x1a\x83\x04\n\x0bMetaInfoDef\x12,\n\x12meta_graph_version\
    \x18\x01\x20\x01(\tR\x10metaGraphVersion\x12<\n\x10stripped_op_list\x18\
    \x02\x20\x01(\x0b2\x12.tensorflow.OpListR\x0estrippedOpList\x12/\n\x08an\
    y_info\x18\x03\x20\x01(\x0b2\x14.google.protobuf.AnyR\x07anyInfo\x12\x12\
    \n\x04tags\x18\x04\x20\x03(\tR\x04tags\x12-\n\x12tensorflow_version\x18\
    \x05\x20\x01(\tR\x11tensorflowVersion\x124\n\x16tensorflow_git_version\
    \x18\x06\x20\x01(\tR\x14tensorflowGitVersion\x124\n\x16stripped_default_\
    attrs\x18\x07\x20\x01(\x08R\x14strippedDefaultAttrs\x12d\n\x10function_a\
    liases\x18\x08\x20\x03(\x0b29.tensorflow.MetaGraphDef.MetaInfoDef.Functi\
    onAliasesEntryR\x0ffunctionAliases\x1aB\n\x14FunctionAliasesEntry\x12\
    \x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\
    \x01(\tR\x05value:\x028\x01\x1a[\n\x12CollectionDefEntry\x12\x10\n\x03ke\
    y\x18\x01\x20\x01(\tR\x03key\x12/\n\x05value\x18\x02\x20\x01(\x0b2\x19.t\
    ensorflow.CollectionDefR\x05value:\x028\x01\x1aY\n\x11SignatureDefEntry\
    \x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12.\n\x05value\x18\x02\x20\
    \x01(\x0b2\x18.tensorflow.SignatureDefR\x05value:\x028\x01\"\xb6\x04\n\r\
    CollectionDef\x12A\n\tnode_list\x18\x01\x20\x01(\x0b2\".tensorflow.Colle\
    ctionDef.NodeListH\0R\x08nodeList\x12D\n\nbytes_list\x18\x02\x20\x01(\
    \x0b2#.tensorflow.CollectionDef.BytesListH\0R\tbytesList\x12D\n\nint64_l\
    ist\x18\x03\x20\x01(\x0b2#.tensorflow.CollectionDef.Int64ListH\0R\tint64\
    List\x12D\n\nfloat_list\x18\x04\x20\x01(\x0b2#.tensorflow.CollectionDef.\
    FloatListH\0R\tfloatList\x12>\n\x08any_list\x18\x05\x20\x01(\x0b2!.tenso\
    rflow.CollectionDef.AnyListH\0R\x07anyList\x1a\x20\n\x08NodeList\x12\x14\
    \n\x05value\x18\x01\x20\x03(\tR\x05value\x1a!\n\tBytesList\x12\x14\n\x05\
    value\x18\x01\x20\x03(\x0cR\x05value\x1a%\n\tInt64List\x12\x18\n\x05valu\
    e\x18\x01\x20\x03(\x03R\x05valueB\x02\x10\x01\x1a%\n\tFloatList\x12\x18\
    \n\x05value\x18\x01\x20\x03(\x02R\x05valueB\x02\x10\x01\x1a5\n\x07AnyLis\
    t\x12*\n\x05value\x18\x01\x20\x03(\x0b2\x14.google.protobuf.AnyR\x05valu\
    eB\x06\n\x04kind\"\xda\x04\n\nTensorInfo\x12\x14\n\x04name\x18\x01\x20\
    \x01(\tH\0R\x04name\x12A\n\ncoo_sparse\x18\x04\x20\x01(\x0b2\x20.tensorf\
    low.TensorInfo.CooSparseH\0R\tcooSparse\x12S\n\x10composite_tensor\x18\
    \x05\x20\x01(\x0b2&.tensorflow.TensorInfo.CompositeTensorH\0R\x0fcomposi\
    teTensor\x12*\n\x05dtype\x18\x02\x20\x01(\x0e2\x14.tensorflow.DataTypeR\
    \x05dtype\x12?\n\x0ctensor_shape\x18\x03\x20\x01(\x0b2\x1c.tensorflow.Te\
    nsorShapeProtoR\x0btensorShape\x1a\xa0\x01\n\tCooSparse\x12,\n\x12values\
    _tensor_name\x18\x01\x20\x01(\tR\x10valuesTensorName\x12.\n\x13indices_t\
    ensor_name\x18\x02\x20\x01(\tR\x11indicesTensorName\x125\n\x17dense_shap\
    e_tensor_name\x18\x03\x20\x01(\tR\x14denseShapeTensorName\x1a\x81\x01\n\
    \x0fCompositeTensor\x126\n\ttype_spec\x18\x01\x20\x01(\x0b2\x19.tensorfl\
    ow.TypeSpecProtoR\x08typeSpec\x126\n\ncomponents\x18\x02\x20\x03(\x0b2\
    \x16.tensorflow.TensorInfoR\ncomponentsB\n\n\x08encoding\"\xd5\x02\n\x0c\
    SignatureDef\x12<\n\x06inputs\x18\x01\x20\x03(\x0b2$.tensorflow.Signatur\
    eDef.InputsEntryR\x06inputs\x12?\n\x07outputs\x18\x02\x20\x03(\x0b2%.ten\
    sorflow.SignatureDef.OutputsEntryR\x07outputs\x12\x1f\n\x0bmethod_name\
    \x18\x03\x20\x01(\tR\nmethodName\x1aQ\n\x0bInputsEntry\x12\x10\n\x03key\
    \x18\x01\x20\x01(\tR\x03key\x12,\n\x05value\x18\x02\x20\x01(\x0b2\x16.te\
    nsorflow.TensorInfoR\x05value:\x028\x01\x1aR\n\x0cOutputsEntry\x12\x10\n\
    \x03key\x18\x01\x20\x01(\tR\x03key\x12,\n\x05value\x18\x02\x20\x01(\x0b2\
    \x16.tensorflow.TensorInfoR\x05value:\x028\x01\"c\n\x0cAssetFileDef\x127\
    \n\x0btensor_info\x18\x01\x20\x01(\x0b2\x16.tensorflow.TensorInfoR\ntens\
    orInfo\x12\x1a\n\x08filename\x18\x02\x20\x01(\tR\x08filenameBz\n\x18org.\
    tensorflow.frameworkB\x0fMetaGraphProtosP\x01ZHgithub.com/tensorflow/ten\
    sorflow/tensorflow/go/core/core_protos_go_proto\xf8\x01\x01J\xa8[\n\x07\
    \x12\x05\0\0\xd5\x02\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\
    \x12\x03\x02\0\x13\n\t\n\x02\x03\0\x12\x03\x04\0#\n\t\n\x02\x03\x01\x12\
    \x03\x05\0/\n\t\n\x02\x03\x02\x12\x03\x06\00\n\t\n\x02\x03\x03\x12\x03\
    \x07\06\n\t\n\x02\x03\x04\x12\x03\x08\0/\n\t\n\x02\x03\x05\x12\x03\t\0;\
    \n\t\n\x02\x03\x06\x12\x03\n\0.\n\t\n\x02\x03\x07\x12\x03\x0b\0/\n\x08\n\
    \x01\x08\x12\x03\r\0\x1f\n\t\n\x02\x08\x1f\x12\x03\r\0\x1f\n\x08\n\x01\
    \x08\x12\x03\x0e\00\n\t\n\x02\x08\x08\x12\x03\x0e\00\n\x08\n\x01\x08\x12\
    \x03\x0f\0\"\n\t\n\x02\x08\n\x12\x03\x0f\0\"\n\x08\n\x01\x08\x12\x03\x10\
    \01\n\t\n\x02\x08\x01\x12\x03\x10\01\n\x08\n\x01\x08\x12\x03\x11\0_\n\t\
    \n\x02\x08\x0b\x12\x03\x11\0_\n\x8a\x04\n\x02\x04\0\x12\x04!\0_\x01\x1a\
    \xfd\x03\x20NOTE:\x20This\x20protocol\x20buffer\x20is\x20evolving,\x20an\
    d\x20will\x20go\x20through\x20revisions\x20in\x20the\n\x20coming\x20mont\
    hs.\n\n\x20Protocol\x20buffer\x20containing\x20the\x20following\x20which\
    \x20are\x20necessary\x20to\x20restart\n\x20training,\x20run\x20inference\
    .\x20It\x20can\x20be\x20used\x20to\x20serialize/de-serialize\x20memory\n\
    \x20objects\x20necessary\x20for\x20running\x20computation\x20in\x20a\x20\
    graph\x20when\x20crossing\x20the\n\x20process\x20boundary.\x20It\x20can\
    \x20be\x20used\x20for\x20long\x20term\x20storage\x20of\x20graphs,\n\x20c\
    ross-language\x20execution\x20of\x20graphs,\x20etc.\n\x20\x20\x20MetaInf\
    oDef\n\x20\x20\x20GraphDef\n\x20\x20\x20SaverDef\n\x20\x20\x20Collection\
    Def\n\x20\x20\x20TensorInfo\n\x20\x20\x20SignatureDef\n\n\n\n\x03\x04\0\
    \x01\x12\x03!\x08\x14\n\xa5\x01\n\x04\x04\0\x03\0\x12\x04$\x02I\x03\x1a\
    \x96\x01\x20Meta\x20information\x20regarding\x20the\x20graph\x20to\x20be\
    \x20exported.\x20\x20To\x20be\x20used\x20by\x20users\n\x20of\x20this\x20\
    protocol\x20buffer\x20to\x20encode\x20information\x20regarding\x20their\
    \x20meta\x20graph.\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03$\n\x15\n\x86\
    \x01\n\x06\x04\0\x03\0\x02\0\x12\x03'\x04\"\x1aw\x20User\x20specified\
    \x20Version\x20string.\x20Can\x20be\x20the\x20name\x20of\x20the\x20model\
    \x20and\x20revision,\n\x20steps\x20this\x20model\x20has\x20been\x20train\
    ed\x20to,\x20etc.\n\n\x0e\n\x07\x04\0\x03\0\x02\0\x05\x12\x03'\x04\n\n\
    \x0e\n\x07\x04\0\x03\0\x02\0\x01\x12\x03'\x0b\x1d\n\x0e\n\x07\x04\0\x03\
    \0\x02\0\x03\x12\x03'\x20!\n\x8b\x01\n\x06\x04\0\x03\0\x02\x01\x12\x03+\
    \x04\x20\x1a|\x20A\x20copy\x20of\x20the\x20OpDefs\x20used\x20by\x20the\
    \x20producer\x20of\x20this\x20graph_def.\n\x20Descriptions\x20and\x20Ops\
    \x20not\x20used\x20in\x20graph_def\x20are\x20stripped\x20out.\n\n\x0e\n\
    \x07\x04\0\x03\0\x02\x01\x06\x12\x03+\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\
    \x01\x01\x12\x03+\x0b\x1b\n\x0e\n\x07\x04\0\x03\0\x02\x01\x03\x12\x03+\
    \x1e\x1f\nw\n\x06\x04\0\x03\0\x02\x02\x12\x03/\x04%\x1ah\x20A\x20seriali\
    zed\x20protobuf.\x20Can\x20be\x20the\x20time\x20this\x20meta\x20graph\
    \x20is\x20created,\x20or\n\x20modified,\x20or\x20name\x20of\x20the\x20mo\
    del.\n\n\x0e\n\x07\x04\0\x03\0\x02\x02\x06\x12\x03/\x04\x17\n\x0e\n\x07\
    \x04\0\x03\0\x02\x02\x01\x12\x03/\x18\x20\n\x0e\n\x07\x04\0\x03\0\x02\
    \x02\x03\x12\x03/#$\n\xba\x02\n\x06\x04\0\x03\0\x02\x03\x12\x037\x04\x1d\
    \x1a\xaa\x02\x20User\x20supplied\x20tag(s)\x20on\x20the\x20meta_graph\
    \x20and\x20included\x20graph_def.\n\n\x20MetaGraphDefs\x20should\x20be\
    \x20tagged\x20with\x20their\x20capabilities\x20or\x20use-cases.\n\x20Exa\
    mples:\x20\"train\",\x20\"serve\",\x20\"gpu\",\x20\"tpu\",\x20etc.\n\x20\
    These\x20tags\x20enable\x20loaders\x20to\x20access\x20the\x20MetaGraph(s\
    )\x20appropriate\x20for\x20a\n\x20specific\x20use-case\x20or\x20runtime\
    \x20environment.\n\n\x0e\n\x07\x04\0\x03\0\x02\x03\x04\x12\x037\x04\x0c\
    \n\x0e\n\x07\x04\0\x03\0\x02\x03\x05\x12\x037\r\x13\n\x0e\n\x07\x04\0\
    \x03\0\x02\x03\x01\x12\x037\x14\x18\n\x0e\n\x07\x04\0\x03\0\x02\x03\x03\
    \x12\x037\x1b\x1c\n\xb3\x01\n\x06\x04\0\x03\0\x02\x04\x12\x03<\x04\"\x1a\
    \xa3\x01\x20The\x20__version__\x20string\x20of\x20the\x20tensorflow\x20b\
    uild\x20used\x20to\x20write\x20this\x20graph.\n\x20This\x20will\x20be\
    \x20populated\x20by\x20the\x20framework,\x20which\x20will\x20overwrite\
    \x20any\x20user\n\x20supplied\x20value.\n\n\x0e\n\x07\x04\0\x03\0\x02\
    \x04\x05\x12\x03<\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\x04\x01\x12\x03<\x0b\
    \x1d\n\x0e\n\x07\x04\0\x03\0\x02\x04\x03\x12\x03<\x20!\n\xb7\x01\n\x06\
    \x04\0\x03\0\x02\x05\x12\x03A\x04&\x1a\xa7\x01\x20The\x20__git_version__\
    \x20string\x20of\x20the\x20tensorflow\x20build\x20used\x20to\x20write\
    \x20this\n\x20graph.\x20This\x20will\x20be\x20populated\x20by\x20the\x20\
    framework,\x20which\x20will\x20overwrite\x20any\n\x20user\x20supplied\
    \x20value.\n\n\x0e\n\x07\x04\0\x03\0\x02\x05\x05\x12\x03A\x04\n\n\x0e\n\
    \x07\x04\0\x03\0\x02\x05\x01\x12\x03A\x0b!\n\x0e\n\x07\x04\0\x03\0\x02\
    \x05\x03\x12\x03A$%\nt\n\x06\x04\0\x03\0\x02\x06\x12\x03E\x04$\x1ae\x20A\
    \x20flag\x20to\x20denote\x20whether\x20default-valued\x20attrs\x20have\
    \x20been\x20stripped\x20from\n\x20the\x20nodes\x20in\x20this\x20graph_de\
    f.\n\n\x0e\n\x07\x04\0\x03\0\x02\x06\x05\x12\x03E\x04\x08\n\x0e\n\x07\
    \x04\0\x03\0\x02\x06\x01\x12\x03E\t\x1f\n\x0e\n\x07\x04\0\x03\0\x02\x06\
    \x03\x12\x03E\"#\n5\n\x06\x04\0\x03\0\x02\x07\x12\x03H\x04-\x1a&\x20Func\
    tionDef\x20name\x20to\x20aliases\x20mapping.\n\n\x0e\n\x07\x04\0\x03\0\
    \x02\x07\x06\x12\x03H\x04\x17\n\x0e\n\x07\x04\0\x03\0\x02\x07\x01\x12\
    \x03H\x18(\n\x0e\n\x07\x04\0\x03\0\x02\x07\x03\x12\x03H+,\n\x0b\n\x04\
    \x04\0\x02\0\x12\x03J\x02\x20\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03J\x02\r\
    \n\x0c\n\x05\x04\0\x02\0\x01\x12\x03J\x0e\x1b\n\x0c\n\x05\x04\0\x02\0\
    \x03\x12\x03J\x1e\x1f\n\x18\n\x04\x04\0\x02\x01\x12\x03M\x02\x19\x1a\x0b\
    \x20GraphDef.\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03M\x02\n\n\x0c\n\x05\
    \x04\0\x02\x01\x01\x12\x03M\x0b\x14\n\x0c\n\x05\x04\0\x02\x01\x03\x12\
    \x03M\x17\x18\n\x18\n\x04\x04\0\x02\x02\x12\x03P\x02\x19\x1a\x0b\x20Save\
    rDef.\n\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03P\x02\n\n\x0c\n\x05\x04\0\
    \x02\x02\x01\x12\x03P\x0b\x14\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03P\x17\
    \x18\no\n\x04\x04\0\x02\x03\x12\x03T\x020\x1ab\x20collection_def:\x20Map\
    \x20from\x20collection\x20name\x20to\x20collections.\n\x20See\x20Collect\
    ionDef\x20section\x20for\x20details.\n\n\x0c\n\x05\x04\0\x02\x03\x06\x12\
    \x03T\x02\x1c\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03T\x1d+\n\x0c\n\x05\
    \x04\0\x02\x03\x03\x12\x03T./\nc\n\x04\x04\0\x02\x04\x12\x03X\x02.\x1aV\
    \x20signature_def:\x20Map\x20from\x20user\x20supplied\x20key\x20for\x20a\
    \x20signature\x20to\x20a\x20single\n\x20SignatureDef.\n\n\x0c\n\x05\x04\
    \0\x02\x04\x06\x12\x03X\x02\x1b\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03X\
    \x1c)\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03X,-\n@\n\x04\x04\0\x02\x05\
    \x12\x03[\x02+\x1a3\x20Asset\x20file\x20def\x20to\x20be\x20used\x20with\
    \x20the\x20defined\x20graph.\n\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x03[\
    \x02\n\n\x0c\n\x05\x04\0\x02\x05\x06\x12\x03[\x0b\x17\n\x0c\n\x05\x04\0\
    \x02\x05\x01\x12\x03[\x18&\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03[)*\nW\n\
    \x04\x04\0\x02\x06\x12\x03^\x02(\x1aJ\x20Extra\x20information\x20about\
    \x20the\x20structure\x20of\x20functions\x20and\x20stateful\x20objects.\n\
    \n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03^\x02\x12\n\x0c\n\x05\x04\0\x02\
    \x06\x01\x12\x03^\x13#\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03^&'\n\xdf\
    \x0f\n\x02\x04\x01\x12\x06\x9f\x01\0\xd5\x01\x01\x1a\xd0\x0f\x20Collecti\
    onDef\x20should\x20cover\x20most\x20collections.\n\x20To\x20add\x20a\x20\
    user-defined\x20collection,\x20do\x20one\x20of\x20the\x20following:\n\
    \x201.\x20For\x20simple\x20data\x20types,\x20such\x20as\x20string,\x20in\
    t,\x20float:\n\x20\x20\x20\x20\x20\x20tf.add_to_collection(\"your_collec\
    tion_name\",\x20your_simple_value)\n\x20\x20\x20\x20strings\x20will\x20b\
    e\x20stored\x20as\x20bytes_list.\n\n\x202.\x20For\x20Protobuf\x20types,\
    \x20there\x20are\x20three\x20ways\x20to\x20add\x20them:\n\x20\x20\x20\
    \x201)\x20tf.add_to_collection(\"your_collection_name\",\n\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20your_proto.SerializeToString())\n\n\x20\x20\x20\
    \x20\x20\x20\x20collection_def\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20key:\x20\"user_defined_bytes_collection\"\n\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20byte\
    s_list\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value:\
    \x20\"queue_name:\x20\\\"test_queue\\\"\\n\"\n\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\
    \x20\x20\x20\x20\x20}\n\n\x20\x20or\n\n\x20\x20\x20\x202)\x20tf.add_to_c\
    ollection(\"your_collection_name\",\x20str(your_proto))\n\n\x20\x20\x20\
    \x20\x20\x20\x20collection_def\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20key:\x20\"user_defined_string_collection\"\n\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20bytes_li\
    st\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value:\x20\
    \"\\n\\ntest_queue\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20}\n\n\
    \x20\x20or\n\n\x20\x20\x20\x203)\x20any_buf\x20=\x20any_pb2.Any()\n\x20\
    \x20\x20\x20\x20\x20\x20tf.add_to_collection(\"your_collection_name\",\n\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20any_buf.Pack(your_proto))\n\n\x20\
    \x20\x20\x20\x20\x20\x20collection_def\x20{\n\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20key:\x20\"user_defined_any_collection\"\n\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20any_list\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20v\
    alue\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20t\
    ype_url:\x20\"type.googleapis.com/tensorflow.QueueRunnerDef\"\n\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value:\x20\"\\n\\nte\
    st_queue\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20}\n\x20\x20\x20\x20\x20\x20\x20}\n\n\x203.\x20For\x20Python\x20o\
    bjects,\x20implement\x20to_proto()\x20and\x20from_proto(),\x20and\x20reg\
    ister\n\x20\x20\x20\x20them\x20in\x20the\x20following\x20manner:\n\x20\
    \x20\x20\x20ops.register_proto_function(\"your_collection_name\",\n\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20proto_type,\n\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20to_proto=YourPythonO\
    bject.to_proto,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20from_proto=YourPythonObject.from_proto)\n\x20\x20\x20\x20These\x20fu\
    nctions\x20will\x20be\x20invoked\x20to\x20serialize\x20and\x20de-seriali\
    ze\x20the\n\x20\x20\x20\x20collection.\x20For\x20example,\n\x20\x20\x20\
    \x20ops.register_proto_function(ops.GraphKeys.GLOBAL_VARIABLES,\n\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20proto_type=variable_\
    pb2.VariableDef,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20to_proto=Variable.to_proto,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20from_proto=Variable.from_proto)\n\n\x0b\n\x03\x04\
    \x01\x01\x12\x04\x9f\x01\x08\x15\n\x98\x02\n\x04\x04\x01\x03\0\x12\x06\
    \xaa\x01\x02\xac\x01\x03\x1a\x87\x02\x20NodeList\x20is\x20used\x20for\
    \x20collecting\x20nodes\x20in\x20graph.\x20For\x20example\n\x20collectio\
    n_def\x20{\n\x20\x20\x20key:\x20\"summaries\"\n\x20\x20\x20value\x20{\n\
    \x20\x20\x20\x20\x20node_list\x20{\n\x20\x20\x20\x20\x20\x20\x20value:\
    \x20\"input_producer/ScalarSummary:0\"\n\x20\x20\x20\x20\x20\x20\x20valu\
    e:\x20\"shuffle_batch/ScalarSummary:0\"\n\x20\x20\x20\x20\x20\x20\x20val\
    ue:\x20\"ImageSummary:0\"\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\n\n\r\n\
    \x05\x04\x01\x03\0\x01\x12\x04\xaa\x01\n\x12\n\x0e\n\x06\x04\x01\x03\0\
    \x02\0\x12\x04\xab\x01\x04\x1e\n\x0f\n\x07\x04\x01\x03\0\x02\0\x04\x12\
    \x04\xab\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\0\x02\0\x05\x12\x04\xab\x01\
    \r\x13\n\x0f\n\x07\x04\x01\x03\0\x02\0\x01\x12\x04\xab\x01\x14\x19\n\x0f\
    \n\x07\x04\x01\x03\0\x02\0\x03\x12\x04\xab\x01\x1c\x1d\n\x96\x03\n\x04\
    \x04\x01\x03\x01\x12\x06\xbb\x01\x02\xbd\x01\x03\x1a\x85\x03\x20BytesLis\
    t\x20is\x20used\x20for\x20collecting\x20strings\x20and\x20serialized\x20\
    protobufs.\x20For\n\x20example:\n\x20collection_def\x20{\n\x20\x20\x20ke\
    y:\x20\"trainable_variables\"\n\x20\x20\x20value\x20{\n\x20\x20\x20\x20\
    \x20bytes_list\x20{\n\x20\x20\x20\x20\x20\x20\x20value:\x20\"\\n\\017con\
    v1/weights:0\\022\\024conv1/weights/Assign\n\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\\032\\024conv1/weights/read:0\"\n\x20\x20\
    \x20\x20\x20\x20\x20value:\x20\"\\n\\016conv1/biases:0\\022\\023conv1/bi\
    ases/Assign\\032\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\\023conv1/biases/read:0\"\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\n\
    \x20}\n\n\r\n\x05\x04\x01\x03\x01\x01\x12\x04\xbb\x01\n\x13\n\x0e\n\x06\
    \x04\x01\x03\x01\x02\0\x12\x04\xbc\x01\x04\x1d\n\x0f\n\x07\x04\x01\x03\
    \x01\x02\0\x04\x12\x04\xbc\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\x01\x02\0\
    \x05\x12\x04\xbc\x01\r\x12\n\x0f\n\x07\x04\x01\x03\x01\x02\0\x01\x12\x04\
    \xbc\x01\x13\x18\n\x0f\n\x07\x04\x01\x03\x01\x02\0\x03\x12\x04\xbc\x01\
    \x1b\x1c\nN\n\x04\x04\x01\x03\x02\x12\x06\xc0\x01\x02\xc2\x01\x03\x1a>\
    \x20Int64List\x20is\x20used\x20for\x20collecting\x20int,\x20int64\x20and\
    \x20long\x20values.\n\n\r\n\x05\x04\x01\x03\x02\x01\x12\x04\xc0\x01\n\
    \x13\n\x0e\n\x06\x04\x01\x03\x02\x02\0\x12\x04\xc1\x01\x04-\n\x0f\n\x07\
    \x04\x01\x03\x02\x02\0\x04\x12\x04\xc1\x01\x04\x0c\n\x0f\n\x07\x04\x01\
    \x03\x02\x02\0\x05\x12\x04\xc1\x01\r\x12\n\x0f\n\x07\x04\x01\x03\x02\x02\
    \0\x01\x12\x04\xc1\x01\x13\x18\n\x0f\n\x07\x04\x01\x03\x02\x02\0\x03\x12\
    \x04\xc1\x01\x1b\x1c\n\x0f\n\x07\x04\x01\x03\x02\x02\0\x08\x12\x04\xc1\
    \x01\x1d,\n\x10\n\x08\x04\x01\x03\x02\x02\0\x08\x02\x12\x04\xc1\x01\x1e+\
    \n@\n\x04\x04\x01\x03\x03\x12\x06\xc5\x01\x02\xc7\x01\x03\x1a0\x20FloatL\
    ist\x20is\x20used\x20for\x20collecting\x20float\x20values.\n\n\r\n\x05\
    \x04\x01\x03\x03\x01\x12\x04\xc5\x01\n\x13\n\x0e\n\x06\x04\x01\x03\x03\
    \x02\0\x12\x04\xc6\x01\x04-\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x04\x12\
    \x04\xc6\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x05\x12\x04\xc6\
    \x01\r\x12\n\x0f\n\x07\x04\x01\x03\x03\x02\0\x01\x12\x04\xc6\x01\x13\x18\
    \n\x0f\n\x07\x04\x01\x03\x03\x02\0\x03\x12\x04\xc6\x01\x1b\x1c\n\x0f\n\
    \x07\x04\x01\x03\x03\x02\0\x08\x12\x04\xc6\x01\x1d,\n\x10\n\x08\x04\x01\
    \x03\x03\x02\0\x08\x02\x12\x04\xc6\x01\x1e+\n<\n\x04\x04\x01\x03\x04\x12\
    \x06\xca\x01\x02\xcc\x01\x03\x1a,\x20AnyList\x20is\x20used\x20for\x20col\
    lecting\x20Any\x20protos.\n\n\r\n\x05\x04\x01\x03\x04\x01\x12\x04\xca\
    \x01\n\x11\n\x0e\n\x06\x04\x01\x03\x04\x02\0\x12\x04\xcb\x01\x04+\n\x0f\
    \n\x07\x04\x01\x03\x04\x02\0\x04\x12\x04\xcb\x01\x04\x0c\n\x0f\n\x07\x04\
    \x01\x03\x04\x02\0\x06\x12\x04\xcb\x01\r\x20\n\x0f\n\x07\x04\x01\x03\x04\
    \x02\0\x01\x12\x04\xcb\x01!&\n\x0f\n\x07\x04\x01\x03\x04\x02\0\x03\x12\
    \x04\xcb\x01)*\n\x0e\n\x04\x04\x01\x08\0\x12\x06\xce\x01\x02\xd4\x01\x03\
    \n\r\n\x05\x04\x01\x08\0\x01\x12\x04\xce\x01\x08\x0c\n\x0c\n\x04\x04\x01\
    \x02\0\x12\x04\xcf\x01\x04\x1b\n\r\n\x05\x04\x01\x02\0\x06\x12\x04\xcf\
    \x01\x04\x0c\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xcf\x01\r\x16\n\r\n\x05\
    \x04\x01\x02\0\x03\x12\x04\xcf\x01\x19\x1a\n\x0c\n\x04\x04\x01\x02\x01\
    \x12\x04\xd0\x01\x04\x1d\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\xd0\x01\
    \x04\r\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\xd0\x01\x0e\x18\n\r\n\x05\
    \x04\x01\x02\x01\x03\x12\x04\xd0\x01\x1b\x1c\n\x0c\n\x04\x04\x01\x02\x02\
    \x12\x04\xd1\x01\x04\x1d\n\r\n\x05\x04\x01\x02\x02\x06\x12\x04\xd1\x01\
    \x04\r\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xd1\x01\x0e\x18\n\r\n\x05\
    \x04\x01\x02\x02\x03\x12\x04\xd1\x01\x1b\x1c\n\x0c\n\x04\x04\x01\x02\x03\
    \x12\x04\xd2\x01\x04\x1d\n\r\n\x05\x04\x01\x02\x03\x06\x12\x04\xd2\x01\
    \x04\r\n\r\n\x05\x04\x01\x02\x03\x01\x12\x04\xd2\x01\x0e\x18\n\r\n\x05\
    \x04\x01\x02\x03\x03\x12\x04\xd2\x01\x1b\x1c\n\x0c\n\x04\x04\x01\x02\x04\
    \x12\x04\xd3\x01\x04\x19\n\r\n\x05\x04\x01\x02\x04\x06\x12\x04\xd3\x01\
    \x04\x0b\n\r\n\x05\x04\x01\x02\x04\x01\x12\x04\xd3\x01\x0c\x14\n\r\n\x05\
    \x04\x01\x02\x04\x03\x12\x04\xd3\x01\x17\x18\nN\n\x02\x04\x02\x12\x06\
    \xd8\x01\0\x81\x02\x01\x1a@\x20Information\x20about\x20a\x20Tensor\x20ne\
    cessary\x20for\x20feeding\x20or\x20retrieval.\n\n\x0b\n\x03\x04\x02\x01\
    \x12\x04\xd8\x01\x08\x12\nf\n\x04\x04\x02\x03\0\x12\x06\xdb\x01\x02\xe6\
    \x01\x03\x1aV\x20For\x20sparse\x20tensors,\x20The\x20COO\x20encoding\x20\
    stores\x20a\x20triple\x20of\x20values,\x20indices,\n\x20and\x20shape.\n\
    \n\r\n\x05\x04\x02\x03\0\x01\x12\x04\xdb\x01\n\x13\n\x9a\x01\n\x06\x04\
    \x02\x03\0\x02\0\x12\x04\xde\x01\x04\"\x1a\x89\x01\x20The\x20shape\x20of\
    \x20the\x20values\x20Tensor\x20is\x20[?].\x20\x20Its\x20dtype\x20must\
    \x20be\x20the\x20dtype\x20of\n\x20the\x20SparseTensor\x20as\x20a\x20whol\
    e,\x20given\x20in\x20the\x20enclosing\x20TensorInfo.\n\n\x0f\n\x07\x04\
    \x02\x03\0\x02\0\x05\x12\x04\xde\x01\x04\n\n\x0f\n\x07\x04\x02\x03\0\x02\
    \0\x01\x12\x04\xde\x01\x0b\x1d\n\x0f\n\x07\x04\x02\x03\0\x02\0\x03\x12\
    \x04\xde\x01\x20!\nL\n\x06\x04\x02\x03\0\x02\x01\x12\x04\xe1\x01\x04#\
    \x1a<\x20The\x20indices\x20Tensor\x20must\x20have\x20dtype\x20int64\x20a\
    nd\x20shape\x20[?,\x20?].\n\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x05\x12\
    \x04\xe1\x01\x04\n\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x04\xe1\x01\
    \x0b\x1e\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x04\xe1\x01!\"\n\xa1\
    \x01\n\x06\x04\x02\x03\0\x02\x02\x12\x04\xe5\x01\x04'\x1a\x90\x01\x20The\
    \x20dynamic\x20logical\x20shape\x20represented\x20by\x20the\x20SparseTen\
    sor\x20is\x20recorded\x20in\n\x20the\x20Tensor\x20referenced\x20here.\
    \x20\x20It\x20must\x20have\x20dtype\x20int64\x20and\x20shape\x20[?].\n\n\
    \x0f\n\x07\x04\x02\x03\0\x02\x02\x05\x12\x04\xe5\x01\x04\n\n\x0f\n\x07\
    \x04\x02\x03\0\x02\x02\x01\x12\x04\xe5\x01\x0b\"\n\x0f\n\x07\x04\x02\x03\
    \0\x02\x02\x03\x12\x04\xe5\x01%&\n9\n\x04\x04\x02\x03\x01\x12\x06\xe9\
    \x01\x02\xef\x01\x03\x1a)\x20Generic\x20encoding\x20for\x20composite\x20\
    tensors.\n\n\r\n\x05\x04\x02\x03\x01\x01\x12\x04\xe9\x01\n\x19\nC\n\x06\
    \x04\x02\x03\x01\x02\0\x12\x04\xeb\x01\x04\x20\x1a3\x20The\x20serialized\
    \x20TypeSpec\x20for\x20the\x20composite\x20tensor.\n\n\x0f\n\x07\x04\x02\
    \x03\x01\x02\0\x06\x12\x04\xeb\x01\x04\x11\n\x0f\n\x07\x04\x02\x03\x01\
    \x02\0\x01\x12\x04\xeb\x01\x12\x1b\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x03\
    \x12\x04\xeb\x01\x1e\x1f\nC\n\x06\x04\x02\x03\x01\x02\x01\x12\x04\xee\
    \x01\x04'\x1a3\x20A\x20TensorInfo\x20for\x20each\x20flattened\x20compone\
    nt\x20tensor.\n\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x04\x12\x04\xee\x01\
    \x04\x0c\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x06\x12\x04\xee\x01\r\x17\n\
    \x0f\n\x07\x04\x02\x03\x01\x02\x01\x01\x12\x04\xee\x01\x18\"\n\x0f\n\x07\
    \x04\x02\x03\x01\x02\x01\x03\x12\x04\xee\x01%&\n\x0e\n\x04\x04\x02\x08\0\
    \x12\x06\xf1\x01\x02\xfb\x01\x03\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\xf1\
    \x01\x08\x10\nI\n\x04\x04\x02\x02\0\x12\x04\xf3\x01\x04\x14\x1a;\x20For\
    \x20dense\x20`Tensor`s,\x20the\x20name\x20of\x20the\x20tensor\x20in\x20t\
    he\x20graph.\n\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xf3\x01\x04\n\n\r\n\
    \x05\x04\x02\x02\0\x01\x12\x04\xf3\x01\x0b\x0f\n\r\n\x05\x04\x02\x02\0\
    \x03\x12\x04\xf3\x01\x12\x13\n\xee\x01\n\x04\x04\x02\x02\x01\x12\x04\xf8\
    \x01\x04\x1d\x1a\xdf\x01\x20There\x20are\x20many\x20possible\x20encoding\
    s\x20of\x20sparse\x20matrices\n\x20(https://en.wikipedia.org/wiki/Sparse\
    _matrix).\x20\x20Currently,\x20TensorFlow\n\x20uses\x20only\x20the\x20CO\
    O\x20encoding.\x20\x20This\x20is\x20supported\x20and\x20documented\x20in\
    \x20the\n\x20SparseTensor\x20Python\x20class.\n\n\r\n\x05\x04\x02\x02\
    \x01\x06\x12\x04\xf8\x01\x04\r\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xf8\
    \x01\x0e\x18\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\xf8\x01\x1b\x1c\n6\n\
    \x04\x04\x02\x02\x02\x12\x04\xfa\x01\x04)\x1a(\x20Generic\x20encoding\
    \x20for\x20CompositeTensors.\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\xfa\
    \x01\x04\x13\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xfa\x01\x14$\n\r\n\
    \x05\x04\x02\x02\x02\x03\x12\x04\xfa\x01'(\n\x0c\n\x04\x04\x02\x02\x03\
    \x12\x04\xfc\x01\x02\x15\n\r\n\x05\x04\x02\x02\x03\x06\x12\x04\xfc\x01\
    \x02\n\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\xfc\x01\x0b\x10\n\r\n\x05\
    \x04\x02\x02\x03\x03\x12\x04\xfc\x01\x13\x14\n\xdf\x01\n\x04\x04\x02\x02\
    \x04\x12\x04\x80\x02\x02$\x1a\xd0\x01\x20The\x20static\x20shape\x20shoul\
    d\x20be\x20recorded\x20here,\x20to\x20the\x20extent\x20that\x20it\x20can\
    \n\x20be\x20known\x20in\x20advance.\x20\x20In\x20the\x20case\x20of\x20a\
    \x20SparseTensor,\x20this\x20field\x20describes\n\x20the\x20logical\x20s\
    hape\x20of\x20the\x20represented\x20tensor\x20(aka\x20dense_shape).\n\n\
    \r\n\x05\x04\x02\x02\x04\x06\x12\x04\x80\x02\x02\x12\n\r\n\x05\x04\x02\
    \x02\x04\x01\x12\x04\x80\x02\x13\x1f\n\r\n\x05\x04\x02\x02\x04\x03\x12\
    \x04\x80\x02\"#\n\xbe\n\n\x02\x04\x03\x12\x06\xbc\x02\0\xca\x02\x01\x1a\
    \xaf\n\x20SignatureDef\x20defines\x20the\x20signature\x20of\x20a\x20comp\
    utation\x20supported\x20by\x20a\x20TensorFlow\n\x20graph.\n\n\x20For\x20\
    example,\x20a\x20model\x20with\x20two\x20loss\x20computations,\x20sharin\
    g\x20a\x20single\x20input,\n\x20might\x20have\x20the\x20following\x20sig\
    nature_def\x20map.\n\n\x20Note\x20that\x20across\x20the\x20two\x20Signat\
    ureDefs\x20\"loss_A\"\x20and\x20\"loss_B\",\x20the\x20input\x20key,\n\
    \x20output\x20key,\x20and\x20method_name\x20are\x20identical,\x20and\x20\
    will\x20be\x20used\x20by\x20system(s)\x20that\n\x20implement\x20or\x20re\
    ly\x20upon\x20this\x20particular\x20loss\x20method.\x20The\x20output\x20\
    tensor\x20names\n\x20differ,\x20demonstrating\x20how\x20different\x20out\
    puts\x20can\x20exist\x20for\x20the\x20same\x20method.\n\n\x20signature_d\
    ef\x20{\n\x20\x20\x20key:\x20\"loss_A\"\n\x20\x20\x20value\x20{\n\x20\
    \x20\x20\x20\x20inputs\x20{\n\x20\x20\x20\x20\x20\x20\x20key:\x20\"input\
    \"\n\x20\x20\x20\x20\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20name:\x20\"input:0\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20dtype:\
    \x20DT_STRING\n\x20\x20\x20\x20\x20\x20\x20\x20\x20tensor_shape:\x20...\
    \n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\
    \x20outputs\x20{\n\x20\x20\x20\x20\x20\x20\x20key:\x20\"loss_output\"\n\
    \x20\x20\x20\x20\x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20name:\x20\"loss_output_A:0\"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20dt\
    ype:\x20DT_FLOAT\n\x20\x20\x20\x20\x20\x20\x20\x20\x20tensor_shape:\x20.\
    ..\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\
    \n\x20\x20\x20...\n\x20\x20\x20method_name:\x20\"some/package/compute_lo\
    ss\"\n\x20}\n\x20signature_def\x20{\n\x20\x20\x20key:\x20\"loss_B\"\n\
    \x20\x20\x20value\x20{\n\x20\x20\x20\x20\x20inputs\x20{\n\x20\x20\x20\
    \x20\x20\x20\x20key:\x20\"input\"\n\x20\x20\x20\x20\x20\x20\x20value\x20\
    {\n\x20\x20\x20\x20\x20\x20\x20\x20\x20name:\x20\"input:0\"\n\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20dtype:\x20DT_STRING\n\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20tensor_shape:\x20...\n\x20\x20\x20\x20\x20\x20\x20}\n\
    \x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20outputs\x20{\n\x20\x20\x20\
    \x20\x20\x20\x20key:\x20\"loss_output\"\n\x20\x20\x20\x20\x20\x20\x20val\
    ue\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20name:\x20\"loss_output_B:0\
    \"\n\x20\x20\x20\x20\x20\x20\x20\x20\x20dtype:\x20DT_FLOAT\n\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20tensor_shape:\x20...\n\x20\x20\x20\x20\x20\x20\
    \x20}\n\x20\x20\x20\x20\x20}\n\x20\x20\x20}\n\x20\x20\x20...\n\x20\x20\
    \x20method_name:\x20\"some/package/compute_loss\"\n\x20}\n\n\x0b\n\x03\
    \x04\x03\x01\x12\x04\xbc\x02\x08\x14\n'\n\x04\x04\x03\x02\0\x12\x04\xbe\
    \x02\x02%\x1a\x19\x20Named\x20input\x20parameters.\n\n\r\n\x05\x04\x03\
    \x02\0\x06\x12\x04\xbe\x02\x02\x19\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\
    \xbe\x02\x1a\x20\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xbe\x02#$\n(\n\x04\
    \x04\x03\x02\x01\x12\x04\xc0\x02\x02&\x1a\x1a\x20Named\x20output\x20para\
    meters.\n\n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\xc0\x02\x02\x19\n\r\n\
    \x05\x04\x03\x02\x01\x01\x12\x04\xc0\x02\x1a!\n\r\n\x05\x04\x03\x02\x01\
    \x03\x12\x04\xc0\x02$%\n\x91\x04\n\x04\x04\x03\x02\x02\x12\x04\xc9\x02\
    \x02\x19\x1a\x82\x04\x20Extensible\x20method_name\x20information\x20enab\
    ling\x20third-party\x20users\x20to\x20mark\x20a\n\x20SignatureDef\x20as\
    \x20supporting\x20a\x20particular\x20method.\x20This\x20enables\x20produ\
    cers\x20and\n\x20consumers\x20of\x20SignatureDefs,\x20e.g.\x20a\x20model\
    \x20definition\x20library\x20and\x20a\x20serving\n\x20library\x20to\x20h\
    ave\x20a\x20clear\x20hand-off\x20regarding\x20the\x20semantics\x20of\x20\
    a\x20computation.\n\n\x20Note\x20that\x20multiple\x20SignatureDefs\x20in\
    \x20a\x20single\x20MetaGraphDef\x20may\x20have\x20the\x20same\n\x20metho\
    d_name.\x20This\x20is\x20commonly\x20used\x20to\x20support\x20multi-head\
    ed\x20computation,\n\x20where\x20a\x20single\x20graph\x20computation\x20\
    may\x20return\x20multiple\x20results.\n\n\r\n\x05\x04\x03\x02\x02\x05\
    \x12\x04\xc9\x02\x02\x08\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xc9\x02\t\
    \x14\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xc9\x02\x17\x18\nb\n\x02\x04\
    \x04\x12\x06\xce\x02\0\xd5\x02\x01\x1aT\x20An\x20asset\x20file\x20def\
    \x20for\x20a\x20single\x20file\x20or\x20a\x20set\x20of\x20sharded\x20fil\
    es\x20with\x20the\x20same\n\x20name.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\
    \xce\x02\x08\x14\n9\n\x04\x04\x04\x02\0\x12\x04\xd0\x02\x02\x1d\x1a+\x20\
    The\x20tensor\x20to\x20bind\x20the\x20asset\x20filename\x20to.\n\n\r\n\
    \x05\x04\x04\x02\0\x06\x12\x04\xd0\x02\x02\x0c\n\r\n\x05\x04\x04\x02\0\
    \x01\x12\x04\xd0\x02\r\x18\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xd0\x02\
    \x1b\x1c\n\xbd\x01\n\x04\x04\x04\x02\x01\x12\x04\xd4\x02\x02\x16\x1a\xae\
    \x01\x20The\x20filename\x20within\x20an\x20assets\x20directory.\x20Note:\
    \x20does\x20not\x20include\x20the\x20path\n\x20prefix,\x20i.e.\x20direct\
    ories.\x20For\x20an\x20asset\x20at\x20/tmp/path/vocab.txt,\x20the\x20fil\
    ename\n\x20would\x20be\x20\"vocab.txt\".\n\n\r\n\x05\x04\x04\x02\x01\x05\
    \x12\x04\xd4\x02\x02\x08\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xd4\x02\t\
    \x11\n\r\n\x05\x04\x04\x02\x01\x03\x12\x04\xd4\x02\x14\x15b\x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;

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

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