// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/lite/toco/model_flags.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3015007 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "tensorflow/lite/toco/types.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(int index);
namespace toco {
class ArraysExtraInfo;
struct ArraysExtraInfoDefaultTypeInternal;
extern ArraysExtraInfoDefaultTypeInternal _ArraysExtraInfo_default_instance_;
class ArraysExtraInfo_Entry;
struct ArraysExtraInfo_EntryDefaultTypeInternal;
extern ArraysExtraInfo_EntryDefaultTypeInternal _ArraysExtraInfo_Entry_default_instance_;
class InputArray;
struct InputArrayDefaultTypeInternal;
extern InputArrayDefaultTypeInternal _InputArray_default_instance_;
class InputArrayShape;
struct InputArrayShapeDefaultTypeInternal;
extern InputArrayShapeDefaultTypeInternal _InputArrayShape_default_instance_;
class ModelFlags;
struct ModelFlagsDefaultTypeInternal;
extern ModelFlagsDefaultTypeInternal _ModelFlags_default_instance_;
class ModelFlags_ModelCheck;
struct ModelFlags_ModelCheckDefaultTypeInternal;
extern ModelFlags_ModelCheckDefaultTypeInternal _ModelFlags_ModelCheck_default_instance_;
class RnnState;
struct RnnStateDefaultTypeInternal;
extern RnnStateDefaultTypeInternal _RnnState_default_instance_;
}  // namespace toco
PROTOBUF_NAMESPACE_OPEN
template<> ::toco::ArraysExtraInfo* Arena::CreateMaybeMessage<::toco::ArraysExtraInfo>(Arena*);
template<> ::toco::ArraysExtraInfo_Entry* Arena::CreateMaybeMessage<::toco::ArraysExtraInfo_Entry>(Arena*);
template<> ::toco::InputArray* Arena::CreateMaybeMessage<::toco::InputArray>(Arena*);
template<> ::toco::InputArrayShape* Arena::CreateMaybeMessage<::toco::InputArrayShape>(Arena*);
template<> ::toco::ModelFlags* Arena::CreateMaybeMessage<::toco::ModelFlags>(Arena*);
template<> ::toco::ModelFlags_ModelCheck* Arena::CreateMaybeMessage<::toco::ModelFlags_ModelCheck>(Arena*);
template<> ::toco::RnnState* Arena::CreateMaybeMessage<::toco::RnnState>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace toco {

// ===================================================================

class InputArrayShape PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.InputArrayShape) */ {
 public:
  inline InputArrayShape() : InputArrayShape(nullptr) {}
  virtual ~InputArrayShape();
  explicit constexpr InputArrayShape(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  InputArrayShape(const InputArrayShape& from);
  InputArrayShape(InputArrayShape&& from) noexcept
    : InputArrayShape() {
    *this = ::std::move(from);
  }

  inline InputArrayShape& operator=(const InputArrayShape& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputArrayShape& operator=(InputArrayShape&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InputArrayShape& default_instance() {
    return *internal_default_instance();
  }
  static inline const InputArrayShape* internal_default_instance() {
    return reinterpret_cast<const InputArrayShape*>(
               &_InputArrayShape_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(InputArrayShape& a, InputArrayShape& b) {
    a.Swap(&b);
  }
  inline void Swap(InputArrayShape* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputArrayShape* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline InputArrayShape* New() const final {
    return CreateMaybeMessage<InputArrayShape>(nullptr);
  }

  InputArrayShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InputArrayShape>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InputArrayShape& from);
  void MergeFrom(const InputArrayShape& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputArrayShape* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.InputArrayShape";
  }
  protected:
  explicit InputArrayShape(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDimsFieldNumber = 2,
  };
  // repeated int32 dims = 2;
  int dims_size() const;
  private:
  int _internal_dims_size() const;
  public:
  void clear_dims();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_dims(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_dims() const;
  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_dims();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 dims(int index) const;
  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      dims() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_dims();

  // @@protoc_insertion_point(class_scope:toco.InputArrayShape)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > dims_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// -------------------------------------------------------------------

class InputArray PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.InputArray) */ {
 public:
  inline InputArray() : InputArray(nullptr) {}
  virtual ~InputArray();
  explicit constexpr InputArray(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  InputArray(const InputArray& from);
  InputArray(InputArray&& from) noexcept
    : InputArray() {
    *this = ::std::move(from);
  }

  inline InputArray& operator=(const InputArray& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputArray& operator=(InputArray&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InputArray& default_instance() {
    return *internal_default_instance();
  }
  static inline const InputArray* internal_default_instance() {
    return reinterpret_cast<const InputArray*>(
               &_InputArray_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(InputArray& a, InputArray& b) {
    a.Swap(&b);
  }
  inline void Swap(InputArray* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputArray* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline InputArray* New() const final {
    return CreateMaybeMessage<InputArray>(nullptr);
  }

  InputArray* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InputArray>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InputArray& from);
  void MergeFrom(const InputArray& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputArray* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.InputArray";
  }
  protected:
  explicit InputArray(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kShapeFieldNumber = 6,
    kMeanValueFieldNumber = 3,
    kDataTypeFieldNumber = 5,
    kStdValueFieldNumber = 4,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional .toco.InputArrayShape shape = 6;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::toco::InputArrayShape& shape() const;
  ::toco::InputArrayShape* release_shape();
  ::toco::InputArrayShape* mutable_shape();
  void set_allocated_shape(::toco::InputArrayShape* shape);
  private:
  const ::toco::InputArrayShape& _internal_shape() const;
  ::toco::InputArrayShape* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::toco::InputArrayShape* shape);
  ::toco::InputArrayShape* unsafe_arena_release_shape();

  // optional float mean_value = 3;
  bool has_mean_value() const;
  private:
  bool _internal_has_mean_value() const;
  public:
  void clear_mean_value();
  float mean_value() const;
  void set_mean_value(float value);
  private:
  float _internal_mean_value() const;
  void _internal_set_mean_value(float value);
  public:

  // optional .toco.IODataType data_type = 5;
  bool has_data_type() const;
  private:
  bool _internal_has_data_type() const;
  public:
  void clear_data_type();
  ::toco::IODataType data_type() const;
  void set_data_type(::toco::IODataType value);
  private:
  ::toco::IODataType _internal_data_type() const;
  void _internal_set_data_type(::toco::IODataType value);
  public:

  // optional float std_value = 4 [default = 1];
  bool has_std_value() const;
  private:
  bool _internal_has_std_value() const;
  public:
  void clear_std_value();
  float std_value() const;
  void set_std_value(float value);
  private:
  float _internal_std_value() const;
  void _internal_set_std_value(float value);
  public:

  // @@protoc_insertion_point(class_scope:toco.InputArray)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::toco::InputArrayShape* shape_;
  float mean_value_;
  int data_type_;
  float std_value_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// -------------------------------------------------------------------

class RnnState PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.RnnState) */ {
 public:
  inline RnnState() : RnnState(nullptr) {}
  virtual ~RnnState();
  explicit constexpr RnnState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RnnState(const RnnState& from);
  RnnState(RnnState&& from) noexcept
    : RnnState() {
    *this = ::std::move(from);
  }

  inline RnnState& operator=(const RnnState& from) {
    CopyFrom(from);
    return *this;
  }
  inline RnnState& operator=(RnnState&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RnnState& default_instance() {
    return *internal_default_instance();
  }
  static inline const RnnState* internal_default_instance() {
    return reinterpret_cast<const RnnState*>(
               &_RnnState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(RnnState& a, RnnState& b) {
    a.Swap(&b);
  }
  inline void Swap(RnnState* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RnnState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RnnState* New() const final {
    return CreateMaybeMessage<RnnState>(nullptr);
  }

  RnnState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RnnState>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RnnState& from);
  void MergeFrom(const RnnState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RnnState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.RnnState";
  }
  protected:
  explicit RnnState(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStateArrayFieldNumber = 1,
    kBackEdgeSourceArrayFieldNumber = 2,
    kSizeFieldNumber = 3,
    kNumDimsFieldNumber = 4,
    kDiscardableFieldNumber = 5,
  };
  // optional string state_array = 1;
  bool has_state_array() const;
  private:
  bool _internal_has_state_array() const;
  public:
  void clear_state_array();
  const std::string& state_array() const;
  void set_state_array(const std::string& value);
  void set_state_array(std::string&& value);
  void set_state_array(const char* value);
  void set_state_array(const char* value, size_t size);
  std::string* mutable_state_array();
  std::string* release_state_array();
  void set_allocated_state_array(std::string* state_array);
  private:
  const std::string& _internal_state_array() const;
  void _internal_set_state_array(const std::string& value);
  std::string* _internal_mutable_state_array();
  public:

  // optional string back_edge_source_array = 2;
  bool has_back_edge_source_array() const;
  private:
  bool _internal_has_back_edge_source_array() const;
  public:
  void clear_back_edge_source_array();
  const std::string& back_edge_source_array() const;
  void set_back_edge_source_array(const std::string& value);
  void set_back_edge_source_array(std::string&& value);
  void set_back_edge_source_array(const char* value);
  void set_back_edge_source_array(const char* value, size_t size);
  std::string* mutable_back_edge_source_array();
  std::string* release_back_edge_source_array();
  void set_allocated_back_edge_source_array(std::string* back_edge_source_array);
  private:
  const std::string& _internal_back_edge_source_array() const;
  void _internal_set_back_edge_source_array(const std::string& value);
  std::string* _internal_mutable_back_edge_source_array();
  public:

  // optional int32 size = 3;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::int32 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_size() const;
  void _internal_set_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 num_dims = 4;
  bool has_num_dims() const;
  private:
  bool _internal_has_num_dims() const;
  public:
  void clear_num_dims();
  ::PROTOBUF_NAMESPACE_ID::int32 num_dims() const;
  void set_num_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_dims() const;
  void _internal_set_num_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool discardable = 5;
  bool has_discardable() const;
  private:
  bool _internal_has_discardable() const;
  public:
  void clear_discardable();
  bool discardable() const;
  void set_discardable(bool value);
  private:
  bool _internal_discardable() const;
  void _internal_set_discardable(bool value);
  public:

  // @@protoc_insertion_point(class_scope:toco.RnnState)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr state_array_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr back_edge_source_array_;
  ::PROTOBUF_NAMESPACE_ID::int32 size_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_dims_;
  bool discardable_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// -------------------------------------------------------------------

class ArraysExtraInfo_Entry PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.ArraysExtraInfo.Entry) */ {
 public:
  inline ArraysExtraInfo_Entry() : ArraysExtraInfo_Entry(nullptr) {}
  virtual ~ArraysExtraInfo_Entry();
  explicit constexpr ArraysExtraInfo_Entry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ArraysExtraInfo_Entry(const ArraysExtraInfo_Entry& from);
  ArraysExtraInfo_Entry(ArraysExtraInfo_Entry&& from) noexcept
    : ArraysExtraInfo_Entry() {
    *this = ::std::move(from);
  }

  inline ArraysExtraInfo_Entry& operator=(const ArraysExtraInfo_Entry& from) {
    CopyFrom(from);
    return *this;
  }
  inline ArraysExtraInfo_Entry& operator=(ArraysExtraInfo_Entry&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ArraysExtraInfo_Entry& default_instance() {
    return *internal_default_instance();
  }
  static inline const ArraysExtraInfo_Entry* internal_default_instance() {
    return reinterpret_cast<const ArraysExtraInfo_Entry*>(
               &_ArraysExtraInfo_Entry_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ArraysExtraInfo_Entry& a, ArraysExtraInfo_Entry& b) {
    a.Swap(&b);
  }
  inline void Swap(ArraysExtraInfo_Entry* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ArraysExtraInfo_Entry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ArraysExtraInfo_Entry* New() const final {
    return CreateMaybeMessage<ArraysExtraInfo_Entry>(nullptr);
  }

  ArraysExtraInfo_Entry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ArraysExtraInfo_Entry>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ArraysExtraInfo_Entry& from);
  void MergeFrom(const ArraysExtraInfo_Entry& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ArraysExtraInfo_Entry* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.ArraysExtraInfo.Entry";
  }
  protected:
  explicit ArraysExtraInfo_Entry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kNameRegexpFieldNumber = 7,
    kShapeFieldNumber = 5,
    kMinFieldNumber = 2,
    kMaxFieldNumber = 3,
    kDataTypeFieldNumber = 4,
    kConstantFloatValueFieldNumber = 6,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional string name_regexp = 7;
  bool has_name_regexp() const;
  private:
  bool _internal_has_name_regexp() const;
  public:
  void clear_name_regexp();
  const std::string& name_regexp() const;
  void set_name_regexp(const std::string& value);
  void set_name_regexp(std::string&& value);
  void set_name_regexp(const char* value);
  void set_name_regexp(const char* value, size_t size);
  std::string* mutable_name_regexp();
  std::string* release_name_regexp();
  void set_allocated_name_regexp(std::string* name_regexp);
  private:
  const std::string& _internal_name_regexp() const;
  void _internal_set_name_regexp(const std::string& value);
  std::string* _internal_mutable_name_regexp();
  public:

  // optional .toco.InputArrayShape shape = 5;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::toco::InputArrayShape& shape() const;
  ::toco::InputArrayShape* release_shape();
  ::toco::InputArrayShape* mutable_shape();
  void set_allocated_shape(::toco::InputArrayShape* shape);
  private:
  const ::toco::InputArrayShape& _internal_shape() const;
  ::toco::InputArrayShape* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::toco::InputArrayShape* shape);
  ::toco::InputArrayShape* unsafe_arena_release_shape();

  // optional double min = 2;
  bool has_min() const;
  private:
  bool _internal_has_min() const;
  public:
  void clear_min();
  double min() const;
  void set_min(double value);
  private:
  double _internal_min() const;
  void _internal_set_min(double value);
  public:

  // optional double max = 3;
  bool has_max() const;
  private:
  bool _internal_has_max() const;
  public:
  void clear_max();
  double max() const;
  void set_max(double value);
  private:
  double _internal_max() const;
  void _internal_set_max(double value);
  public:

  // optional .toco.IODataType data_type = 4;
  bool has_data_type() const;
  private:
  bool _internal_has_data_type() const;
  public:
  void clear_data_type();
  ::toco::IODataType data_type() const;
  void set_data_type(::toco::IODataType value);
  private:
  ::toco::IODataType _internal_data_type() const;
  void _internal_set_data_type(::toco::IODataType value);
  public:

  // optional float constant_float_value = 6;
  bool has_constant_float_value() const;
  private:
  bool _internal_has_constant_float_value() const;
  public:
  void clear_constant_float_value();
  float constant_float_value() const;
  void set_constant_float_value(float value);
  private:
  float _internal_constant_float_value() const;
  void _internal_set_constant_float_value(float value);
  public:

  // @@protoc_insertion_point(class_scope:toco.ArraysExtraInfo.Entry)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_regexp_;
  ::toco::InputArrayShape* shape_;
  double min_;
  double max_;
  int data_type_;
  float constant_float_value_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// -------------------------------------------------------------------

class ArraysExtraInfo PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.ArraysExtraInfo) */ {
 public:
  inline ArraysExtraInfo() : ArraysExtraInfo(nullptr) {}
  virtual ~ArraysExtraInfo();
  explicit constexpr ArraysExtraInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ArraysExtraInfo(const ArraysExtraInfo& from);
  ArraysExtraInfo(ArraysExtraInfo&& from) noexcept
    : ArraysExtraInfo() {
    *this = ::std::move(from);
  }

  inline ArraysExtraInfo& operator=(const ArraysExtraInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline ArraysExtraInfo& operator=(ArraysExtraInfo&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ArraysExtraInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const ArraysExtraInfo* internal_default_instance() {
    return reinterpret_cast<const ArraysExtraInfo*>(
               &_ArraysExtraInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ArraysExtraInfo& a, ArraysExtraInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(ArraysExtraInfo* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ArraysExtraInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ArraysExtraInfo* New() const final {
    return CreateMaybeMessage<ArraysExtraInfo>(nullptr);
  }

  ArraysExtraInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ArraysExtraInfo>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ArraysExtraInfo& from);
  void MergeFrom(const ArraysExtraInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ArraysExtraInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.ArraysExtraInfo";
  }
  protected:
  explicit ArraysExtraInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  typedef ArraysExtraInfo_Entry Entry;

  // accessors -------------------------------------------------------

  enum : int {
    kEntriesFieldNumber = 1,
  };
  // repeated .toco.ArraysExtraInfo.Entry entries = 1;
  int entries_size() const;
  private:
  int _internal_entries_size() const;
  public:
  void clear_entries();
  ::toco::ArraysExtraInfo_Entry* mutable_entries(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ArraysExtraInfo_Entry >*
      mutable_entries();
  private:
  const ::toco::ArraysExtraInfo_Entry& _internal_entries(int index) const;
  ::toco::ArraysExtraInfo_Entry* _internal_add_entries();
  public:
  const ::toco::ArraysExtraInfo_Entry& entries(int index) const;
  ::toco::ArraysExtraInfo_Entry* add_entries();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ArraysExtraInfo_Entry >&
      entries() const;

  // @@protoc_insertion_point(class_scope:toco.ArraysExtraInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ArraysExtraInfo_Entry > entries_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// -------------------------------------------------------------------

class ModelFlags_ModelCheck PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.ModelFlags.ModelCheck) */ {
 public:
  inline ModelFlags_ModelCheck() : ModelFlags_ModelCheck(nullptr) {}
  virtual ~ModelFlags_ModelCheck();
  explicit constexpr ModelFlags_ModelCheck(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ModelFlags_ModelCheck(const ModelFlags_ModelCheck& from);
  ModelFlags_ModelCheck(ModelFlags_ModelCheck&& from) noexcept
    : ModelFlags_ModelCheck() {
    *this = ::std::move(from);
  }

  inline ModelFlags_ModelCheck& operator=(const ModelFlags_ModelCheck& from) {
    CopyFrom(from);
    return *this;
  }
  inline ModelFlags_ModelCheck& operator=(ModelFlags_ModelCheck&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ModelFlags_ModelCheck& default_instance() {
    return *internal_default_instance();
  }
  static inline const ModelFlags_ModelCheck* internal_default_instance() {
    return reinterpret_cast<const ModelFlags_ModelCheck*>(
               &_ModelFlags_ModelCheck_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(ModelFlags_ModelCheck& a, ModelFlags_ModelCheck& b) {
    a.Swap(&b);
  }
  inline void Swap(ModelFlags_ModelCheck* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ModelFlags_ModelCheck* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ModelFlags_ModelCheck* New() const final {
    return CreateMaybeMessage<ModelFlags_ModelCheck>(nullptr);
  }

  ModelFlags_ModelCheck* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ModelFlags_ModelCheck>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ModelFlags_ModelCheck& from);
  void MergeFrom(const ModelFlags_ModelCheck& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ModelFlags_ModelCheck* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.ModelFlags.ModelCheck";
  }
  protected:
  explicit ModelFlags_ModelCheck(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCountTypeFieldNumber = 1,
    kCountMinFieldNumber = 2,
    kCountMaxFieldNumber = 3,
  };
  // optional string count_type = 1 [default = "None"];
  bool has_count_type() const;
  private:
  bool _internal_has_count_type() const;
  public:
  void clear_count_type();
  const std::string& count_type() const;
  void set_count_type(const std::string& value);
  void set_count_type(std::string&& value);
  void set_count_type(const char* value);
  void set_count_type(const char* value, size_t size);
  std::string* mutable_count_type();
  std::string* release_count_type();
  void set_allocated_count_type(std::string* count_type);
  private:
  const std::string& _internal_count_type() const;
  void _internal_set_count_type(const std::string& value);
  std::string* _internal_mutable_count_type();
  public:

  // optional int32 count_min = 2 [default = -1];
  bool has_count_min() const;
  private:
  bool _internal_has_count_min() const;
  public:
  void clear_count_min();
  ::PROTOBUF_NAMESPACE_ID::int32 count_min() const;
  void set_count_min(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_count_min() const;
  void _internal_set_count_min(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 count_max = 3 [default = -1];
  bool has_count_max() const;
  private:
  bool _internal_has_count_max() const;
  public:
  void clear_count_max();
  ::PROTOBUF_NAMESPACE_ID::int32 count_max() const;
  void set_count_max(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_count_max() const;
  void _internal_set_count_max(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:toco.ModelFlags.ModelCheck)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_count_type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr count_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 count_min_;
  ::PROTOBUF_NAMESPACE_ID::int32 count_max_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// -------------------------------------------------------------------

class ModelFlags PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:toco.ModelFlags) */ {
 public:
  inline ModelFlags() : ModelFlags(nullptr) {}
  virtual ~ModelFlags();
  explicit constexpr ModelFlags(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ModelFlags(const ModelFlags& from);
  ModelFlags(ModelFlags&& from) noexcept
    : ModelFlags() {
    *this = ::std::move(from);
  }

  inline ModelFlags& operator=(const ModelFlags& from) {
    CopyFrom(from);
    return *this;
  }
  inline ModelFlags& operator=(ModelFlags&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ModelFlags& default_instance() {
    return *internal_default_instance();
  }
  static inline const ModelFlags* internal_default_instance() {
    return reinterpret_cast<const ModelFlags*>(
               &_ModelFlags_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(ModelFlags& a, ModelFlags& b) {
    a.Swap(&b);
  }
  inline void Swap(ModelFlags* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ModelFlags* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ModelFlags* New() const final {
    return CreateMaybeMessage<ModelFlags>(nullptr);
  }

  ModelFlags* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ModelFlags>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ModelFlags& from);
  void MergeFrom(const ModelFlags& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ModelFlags* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "toco.ModelFlags";
  }
  protected:
  explicit ModelFlags(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  typedef ModelFlags_ModelCheck ModelCheck;

  // accessors -------------------------------------------------------

  enum : int {
    kInputArraysFieldNumber = 1,
    kOutputArraysFieldNumber = 2,
    kRnnStatesFieldNumber = 12,
    kModelChecksFieldNumber = 14,
    kSavedModelTagsFieldNumber = 22,
    kSavedModelExportedNamesFieldNumber = 23,
    kSavedModelDirFieldNumber = 20,
    kArraysExtraInfoFieldNumber = 18,
    kVariableBatchFieldNumber = 10,
    kAllowNonexistentArraysFieldNumber = 16,
    kAllowNonasciiArraysFieldNumber = 17,
    kSavedModelVersionFieldNumber = 21,
    kChangeConcatInputRangesFieldNumber = 19,
  };
  // repeated .toco.InputArray input_arrays = 1;
  int input_arrays_size() const;
  private:
  int _internal_input_arrays_size() const;
  public:
  void clear_input_arrays();
  ::toco::InputArray* mutable_input_arrays(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::InputArray >*
      mutable_input_arrays();
  private:
  const ::toco::InputArray& _internal_input_arrays(int index) const;
  ::toco::InputArray* _internal_add_input_arrays();
  public:
  const ::toco::InputArray& input_arrays(int index) const;
  ::toco::InputArray* add_input_arrays();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::InputArray >&
      input_arrays() const;

  // repeated string output_arrays = 2;
  int output_arrays_size() const;
  private:
  int _internal_output_arrays_size() const;
  public:
  void clear_output_arrays();
  const std::string& output_arrays(int index) const;
  std::string* mutable_output_arrays(int index);
  void set_output_arrays(int index, const std::string& value);
  void set_output_arrays(int index, std::string&& value);
  void set_output_arrays(int index, const char* value);
  void set_output_arrays(int index, const char* value, size_t size);
  std::string* add_output_arrays();
  void add_output_arrays(const std::string& value);
  void add_output_arrays(std::string&& value);
  void add_output_arrays(const char* value);
  void add_output_arrays(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output_arrays() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output_arrays();
  private:
  const std::string& _internal_output_arrays(int index) const;
  std::string* _internal_add_output_arrays();
  public:

  // repeated .toco.RnnState rnn_states = 12;
  int rnn_states_size() const;
  private:
  int _internal_rnn_states_size() const;
  public:
  void clear_rnn_states();
  ::toco::RnnState* mutable_rnn_states(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::RnnState >*
      mutable_rnn_states();
  private:
  const ::toco::RnnState& _internal_rnn_states(int index) const;
  ::toco::RnnState* _internal_add_rnn_states();
  public:
  const ::toco::RnnState& rnn_states(int index) const;
  ::toco::RnnState* add_rnn_states();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::RnnState >&
      rnn_states() const;

  // repeated .toco.ModelFlags.ModelCheck model_checks = 14;
  int model_checks_size() const;
  private:
  int _internal_model_checks_size() const;
  public:
  void clear_model_checks();
  ::toco::ModelFlags_ModelCheck* mutable_model_checks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ModelFlags_ModelCheck >*
      mutable_model_checks();
  private:
  const ::toco::ModelFlags_ModelCheck& _internal_model_checks(int index) const;
  ::toco::ModelFlags_ModelCheck* _internal_add_model_checks();
  public:
  const ::toco::ModelFlags_ModelCheck& model_checks(int index) const;
  ::toco::ModelFlags_ModelCheck* add_model_checks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ModelFlags_ModelCheck >&
      model_checks() const;

  // repeated string saved_model_tags = 22;
  int saved_model_tags_size() const;
  private:
  int _internal_saved_model_tags_size() const;
  public:
  void clear_saved_model_tags();
  const std::string& saved_model_tags(int index) const;
  std::string* mutable_saved_model_tags(int index);
  void set_saved_model_tags(int index, const std::string& value);
  void set_saved_model_tags(int index, std::string&& value);
  void set_saved_model_tags(int index, const char* value);
  void set_saved_model_tags(int index, const char* value, size_t size);
  std::string* add_saved_model_tags();
  void add_saved_model_tags(const std::string& value);
  void add_saved_model_tags(std::string&& value);
  void add_saved_model_tags(const char* value);
  void add_saved_model_tags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& saved_model_tags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_saved_model_tags();
  private:
  const std::string& _internal_saved_model_tags(int index) const;
  std::string* _internal_add_saved_model_tags();
  public:

  // repeated string saved_model_exported_names = 23;
  int saved_model_exported_names_size() const;
  private:
  int _internal_saved_model_exported_names_size() const;
  public:
  void clear_saved_model_exported_names();
  const std::string& saved_model_exported_names(int index) const;
  std::string* mutable_saved_model_exported_names(int index);
  void set_saved_model_exported_names(int index, const std::string& value);
  void set_saved_model_exported_names(int index, std::string&& value);
  void set_saved_model_exported_names(int index, const char* value);
  void set_saved_model_exported_names(int index, const char* value, size_t size);
  std::string* add_saved_model_exported_names();
  void add_saved_model_exported_names(const std::string& value);
  void add_saved_model_exported_names(std::string&& value);
  void add_saved_model_exported_names(const char* value);
  void add_saved_model_exported_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& saved_model_exported_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_saved_model_exported_names();
  private:
  const std::string& _internal_saved_model_exported_names(int index) const;
  std::string* _internal_add_saved_model_exported_names();
  public:

  // optional string saved_model_dir = 20;
  bool has_saved_model_dir() const;
  private:
  bool _internal_has_saved_model_dir() const;
  public:
  void clear_saved_model_dir();
  const std::string& saved_model_dir() const;
  void set_saved_model_dir(const std::string& value);
  void set_saved_model_dir(std::string&& value);
  void set_saved_model_dir(const char* value);
  void set_saved_model_dir(const char* value, size_t size);
  std::string* mutable_saved_model_dir();
  std::string* release_saved_model_dir();
  void set_allocated_saved_model_dir(std::string* saved_model_dir);
  private:
  const std::string& _internal_saved_model_dir() const;
  void _internal_set_saved_model_dir(const std::string& value);
  std::string* _internal_mutable_saved_model_dir();
  public:

  // optional .toco.ArraysExtraInfo arrays_extra_info = 18;
  bool has_arrays_extra_info() const;
  private:
  bool _internal_has_arrays_extra_info() const;
  public:
  void clear_arrays_extra_info();
  const ::toco::ArraysExtraInfo& arrays_extra_info() const;
  ::toco::ArraysExtraInfo* release_arrays_extra_info();
  ::toco::ArraysExtraInfo* mutable_arrays_extra_info();
  void set_allocated_arrays_extra_info(::toco::ArraysExtraInfo* arrays_extra_info);
  private:
  const ::toco::ArraysExtraInfo& _internal_arrays_extra_info() const;
  ::toco::ArraysExtraInfo* _internal_mutable_arrays_extra_info();
  public:
  void unsafe_arena_set_allocated_arrays_extra_info(
      ::toco::ArraysExtraInfo* arrays_extra_info);
  ::toco::ArraysExtraInfo* unsafe_arena_release_arrays_extra_info();

  // optional bool variable_batch = 10;
  bool has_variable_batch() const;
  private:
  bool _internal_has_variable_batch() const;
  public:
  void clear_variable_batch();
  bool variable_batch() const;
  void set_variable_batch(bool value);
  private:
  bool _internal_variable_batch() const;
  void _internal_set_variable_batch(bool value);
  public:

  // optional bool allow_nonexistent_arrays = 16;
  bool has_allow_nonexistent_arrays() const;
  private:
  bool _internal_has_allow_nonexistent_arrays() const;
  public:
  void clear_allow_nonexistent_arrays();
  bool allow_nonexistent_arrays() const;
  void set_allow_nonexistent_arrays(bool value);
  private:
  bool _internal_allow_nonexistent_arrays() const;
  void _internal_set_allow_nonexistent_arrays(bool value);
  public:

  // optional bool allow_nonascii_arrays = 17;
  bool has_allow_nonascii_arrays() const;
  private:
  bool _internal_has_allow_nonascii_arrays() const;
  public:
  void clear_allow_nonascii_arrays();
  bool allow_nonascii_arrays() const;
  void set_allow_nonascii_arrays(bool value);
  private:
  bool _internal_allow_nonascii_arrays() const;
  void _internal_set_allow_nonascii_arrays(bool value);
  public:

  // optional int32 saved_model_version = 21;
  bool has_saved_model_version() const;
  private:
  bool _internal_has_saved_model_version() const;
  public:
  void clear_saved_model_version();
  ::PROTOBUF_NAMESPACE_ID::int32 saved_model_version() const;
  void set_saved_model_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_saved_model_version() const;
  void _internal_set_saved_model_version(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool change_concat_input_ranges = 19 [default = true];
  bool has_change_concat_input_ranges() const;
  private:
  bool _internal_has_change_concat_input_ranges() const;
  public:
  void clear_change_concat_input_ranges();
  bool change_concat_input_ranges() const;
  void set_change_concat_input_ranges(bool value);
  private:
  bool _internal_change_concat_input_ranges() const;
  void _internal_set_change_concat_input_ranges(bool value);
  public:

  // @@protoc_insertion_point(class_scope:toco.ModelFlags)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::InputArray > input_arrays_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_arrays_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::RnnState > rnn_states_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ModelFlags_ModelCheck > model_checks_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> saved_model_tags_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> saved_model_exported_names_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr saved_model_dir_;
  ::toco::ArraysExtraInfo* arrays_extra_info_;
  bool variable_batch_;
  bool allow_nonexistent_arrays_;
  bool allow_nonascii_arrays_;
  ::PROTOBUF_NAMESPACE_ID::int32 saved_model_version_;
  bool change_concat_input_ranges_;
  friend struct ::TableStruct_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// InputArrayShape

// repeated int32 dims = 2;
inline int InputArrayShape::_internal_dims_size() const {
  return dims_.size();
}
inline int InputArrayShape::dims_size() const {
  return _internal_dims_size();
}
inline void InputArrayShape::clear_dims() {
  dims_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 InputArrayShape::_internal_dims(int index) const {
  return dims_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 InputArrayShape::dims(int index) const {
  // @@protoc_insertion_point(field_get:toco.InputArrayShape.dims)
  return _internal_dims(index);
}
inline void InputArrayShape::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  dims_.Set(index, value);
  // @@protoc_insertion_point(field_set:toco.InputArrayShape.dims)
}
inline void InputArrayShape::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
  dims_.Add(value);
}
inline void InputArrayShape::add_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_dims(value);
  // @@protoc_insertion_point(field_add:toco.InputArrayShape.dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
InputArrayShape::_internal_dims() const {
  return dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
InputArrayShape::dims() const {
  // @@protoc_insertion_point(field_list:toco.InputArrayShape.dims)
  return _internal_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
InputArrayShape::_internal_mutable_dims() {
  return &dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
InputArrayShape::mutable_dims() {
  // @@protoc_insertion_point(field_mutable_list:toco.InputArrayShape.dims)
  return _internal_mutable_dims();
}

// -------------------------------------------------------------------

// InputArray

// optional string name = 1;
inline bool InputArray::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool InputArray::has_name() const {
  return _internal_has_name();
}
inline void InputArray::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& InputArray::name() const {
  // @@protoc_insertion_point(field_get:toco.InputArray.name)
  return _internal_name();
}
inline void InputArray::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:toco.InputArray.name)
}
inline std::string* InputArray::mutable_name() {
  // @@protoc_insertion_point(field_mutable:toco.InputArray.name)
  return _internal_mutable_name();
}
inline const std::string& InputArray::_internal_name() const {
  return name_.Get();
}
inline void InputArray::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void InputArray::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.InputArray.name)
}
inline void InputArray::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.InputArray.name)
}
inline void InputArray::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.InputArray.name)
}
inline std::string* InputArray::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* InputArray::release_name() {
  // @@protoc_insertion_point(field_release:toco.InputArray.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void InputArray::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.InputArray.name)
}

// optional .toco.InputArrayShape shape = 6;
inline bool InputArray::_internal_has_shape() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || shape_ != nullptr);
  return value;
}
inline bool InputArray::has_shape() const {
  return _internal_has_shape();
}
inline void InputArray::clear_shape() {
  if (shape_ != nullptr) shape_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::toco::InputArrayShape& InputArray::_internal_shape() const {
  const ::toco::InputArrayShape* p = shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::toco::InputArrayShape&>(
      ::toco::_InputArrayShape_default_instance_);
}
inline const ::toco::InputArrayShape& InputArray::shape() const {
  // @@protoc_insertion_point(field_get:toco.InputArray.shape)
  return _internal_shape();
}
inline void InputArray::unsafe_arena_set_allocated_shape(
    ::toco::InputArrayShape* shape) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
  }
  shape_ = shape;
  if (shape) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:toco.InputArray.shape)
}
inline ::toco::InputArrayShape* InputArray::release_shape() {
  _has_bits_[0] &= ~0x00000002u;
  ::toco::InputArrayShape* temp = shape_;
  shape_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::toco::InputArrayShape* InputArray::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:toco.InputArray.shape)
  _has_bits_[0] &= ~0x00000002u;
  ::toco::InputArrayShape* temp = shape_;
  shape_ = nullptr;
  return temp;
}
inline ::toco::InputArrayShape* InputArray::_internal_mutable_shape() {
  _has_bits_[0] |= 0x00000002u;
  if (shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::toco::InputArrayShape>(GetArena());
    shape_ = p;
  }
  return shape_;
}
inline ::toco::InputArrayShape* InputArray::mutable_shape() {
  // @@protoc_insertion_point(field_mutable:toco.InputArray.shape)
  return _internal_mutable_shape();
}
inline void InputArray::set_allocated_shape(::toco::InputArrayShape* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete shape_;
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:toco.InputArray.shape)
}

// optional float mean_value = 3;
inline bool InputArray::_internal_has_mean_value() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool InputArray::has_mean_value() const {
  return _internal_has_mean_value();
}
inline void InputArray::clear_mean_value() {
  mean_value_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float InputArray::_internal_mean_value() const {
  return mean_value_;
}
inline float InputArray::mean_value() const {
  // @@protoc_insertion_point(field_get:toco.InputArray.mean_value)
  return _internal_mean_value();
}
inline void InputArray::_internal_set_mean_value(float value) {
  _has_bits_[0] |= 0x00000004u;
  mean_value_ = value;
}
inline void InputArray::set_mean_value(float value) {
  _internal_set_mean_value(value);
  // @@protoc_insertion_point(field_set:toco.InputArray.mean_value)
}

// optional float std_value = 4 [default = 1];
inline bool InputArray::_internal_has_std_value() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool InputArray::has_std_value() const {
  return _internal_has_std_value();
}
inline void InputArray::clear_std_value() {
  std_value_ = 1;
  _has_bits_[0] &= ~0x00000010u;
}
inline float InputArray::_internal_std_value() const {
  return std_value_;
}
inline float InputArray::std_value() const {
  // @@protoc_insertion_point(field_get:toco.InputArray.std_value)
  return _internal_std_value();
}
inline void InputArray::_internal_set_std_value(float value) {
  _has_bits_[0] |= 0x00000010u;
  std_value_ = value;
}
inline void InputArray::set_std_value(float value) {
  _internal_set_std_value(value);
  // @@protoc_insertion_point(field_set:toco.InputArray.std_value)
}

// optional .toco.IODataType data_type = 5;
inline bool InputArray::_internal_has_data_type() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool InputArray::has_data_type() const {
  return _internal_has_data_type();
}
inline void InputArray::clear_data_type() {
  data_type_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::toco::IODataType InputArray::_internal_data_type() const {
  return static_cast< ::toco::IODataType >(data_type_);
}
inline ::toco::IODataType InputArray::data_type() const {
  // @@protoc_insertion_point(field_get:toco.InputArray.data_type)
  return _internal_data_type();
}
inline void InputArray::_internal_set_data_type(::toco::IODataType value) {
  assert(::toco::IODataType_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  data_type_ = value;
}
inline void InputArray::set_data_type(::toco::IODataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:toco.InputArray.data_type)
}

// -------------------------------------------------------------------

// RnnState

// optional string state_array = 1;
inline bool RnnState::_internal_has_state_array() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RnnState::has_state_array() const {
  return _internal_has_state_array();
}
inline void RnnState::clear_state_array() {
  state_array_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& RnnState::state_array() const {
  // @@protoc_insertion_point(field_get:toco.RnnState.state_array)
  return _internal_state_array();
}
inline void RnnState::set_state_array(const std::string& value) {
  _internal_set_state_array(value);
  // @@protoc_insertion_point(field_set:toco.RnnState.state_array)
}
inline std::string* RnnState::mutable_state_array() {
  // @@protoc_insertion_point(field_mutable:toco.RnnState.state_array)
  return _internal_mutable_state_array();
}
inline const std::string& RnnState::_internal_state_array() const {
  return state_array_.Get();
}
inline void RnnState::_internal_set_state_array(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  state_array_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RnnState::set_state_array(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  state_array_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.RnnState.state_array)
}
inline void RnnState::set_state_array(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  state_array_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.RnnState.state_array)
}
inline void RnnState::set_state_array(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  state_array_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.RnnState.state_array)
}
inline std::string* RnnState::_internal_mutable_state_array() {
  _has_bits_[0] |= 0x00000001u;
  return state_array_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RnnState::release_state_array() {
  // @@protoc_insertion_point(field_release:toco.RnnState.state_array)
  if (!_internal_has_state_array()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return state_array_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RnnState::set_allocated_state_array(std::string* state_array) {
  if (state_array != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  state_array_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), state_array,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.RnnState.state_array)
}

// optional string back_edge_source_array = 2;
inline bool RnnState::_internal_has_back_edge_source_array() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RnnState::has_back_edge_source_array() const {
  return _internal_has_back_edge_source_array();
}
inline void RnnState::clear_back_edge_source_array() {
  back_edge_source_array_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& RnnState::back_edge_source_array() const {
  // @@protoc_insertion_point(field_get:toco.RnnState.back_edge_source_array)
  return _internal_back_edge_source_array();
}
inline void RnnState::set_back_edge_source_array(const std::string& value) {
  _internal_set_back_edge_source_array(value);
  // @@protoc_insertion_point(field_set:toco.RnnState.back_edge_source_array)
}
inline std::string* RnnState::mutable_back_edge_source_array() {
  // @@protoc_insertion_point(field_mutable:toco.RnnState.back_edge_source_array)
  return _internal_mutable_back_edge_source_array();
}
inline const std::string& RnnState::_internal_back_edge_source_array() const {
  return back_edge_source_array_.Get();
}
inline void RnnState::_internal_set_back_edge_source_array(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  back_edge_source_array_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RnnState::set_back_edge_source_array(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  back_edge_source_array_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.RnnState.back_edge_source_array)
}
inline void RnnState::set_back_edge_source_array(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  back_edge_source_array_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.RnnState.back_edge_source_array)
}
inline void RnnState::set_back_edge_source_array(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  back_edge_source_array_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.RnnState.back_edge_source_array)
}
inline std::string* RnnState::_internal_mutable_back_edge_source_array() {
  _has_bits_[0] |= 0x00000002u;
  return back_edge_source_array_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RnnState::release_back_edge_source_array() {
  // @@protoc_insertion_point(field_release:toco.RnnState.back_edge_source_array)
  if (!_internal_has_back_edge_source_array()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return back_edge_source_array_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RnnState::set_allocated_back_edge_source_array(std::string* back_edge_source_array) {
  if (back_edge_source_array != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  back_edge_source_array_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), back_edge_source_array,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.RnnState.back_edge_source_array)
}

// optional bool discardable = 5;
inline bool RnnState::_internal_has_discardable() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool RnnState::has_discardable() const {
  return _internal_has_discardable();
}
inline void RnnState::clear_discardable() {
  discardable_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool RnnState::_internal_discardable() const {
  return discardable_;
}
inline bool RnnState::discardable() const {
  // @@protoc_insertion_point(field_get:toco.RnnState.discardable)
  return _internal_discardable();
}
inline void RnnState::_internal_set_discardable(bool value) {
  _has_bits_[0] |= 0x00000010u;
  discardable_ = value;
}
inline void RnnState::set_discardable(bool value) {
  _internal_set_discardable(value);
  // @@protoc_insertion_point(field_set:toco.RnnState.discardable)
}

// optional int32 size = 3;
inline bool RnnState::_internal_has_size() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RnnState::has_size() const {
  return _internal_has_size();
}
inline void RnnState::clear_size() {
  size_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RnnState::_internal_size() const {
  return size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RnnState::size() const {
  // @@protoc_insertion_point(field_get:toco.RnnState.size)
  return _internal_size();
}
inline void RnnState::_internal_set_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  size_ = value;
}
inline void RnnState::set_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:toco.RnnState.size)
}

// optional int32 num_dims = 4;
inline bool RnnState::_internal_has_num_dims() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RnnState::has_num_dims() const {
  return _internal_has_num_dims();
}
inline void RnnState::clear_num_dims() {
  num_dims_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RnnState::_internal_num_dims() const {
  return num_dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RnnState::num_dims() const {
  // @@protoc_insertion_point(field_get:toco.RnnState.num_dims)
  return _internal_num_dims();
}
inline void RnnState::_internal_set_num_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  num_dims_ = value;
}
inline void RnnState::set_num_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_num_dims(value);
  // @@protoc_insertion_point(field_set:toco.RnnState.num_dims)
}

// -------------------------------------------------------------------

// ArraysExtraInfo_Entry

// optional string name = 1;
inline bool ArraysExtraInfo_Entry::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ArraysExtraInfo_Entry::has_name() const {
  return _internal_has_name();
}
inline void ArraysExtraInfo_Entry::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ArraysExtraInfo_Entry::name() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.name)
  return _internal_name();
}
inline void ArraysExtraInfo_Entry::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:toco.ArraysExtraInfo.Entry.name)
}
inline std::string* ArraysExtraInfo_Entry::mutable_name() {
  // @@protoc_insertion_point(field_mutable:toco.ArraysExtraInfo.Entry.name)
  return _internal_mutable_name();
}
inline const std::string& ArraysExtraInfo_Entry::_internal_name() const {
  return name_.Get();
}
inline void ArraysExtraInfo_Entry::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ArraysExtraInfo_Entry::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.ArraysExtraInfo.Entry.name)
}
inline void ArraysExtraInfo_Entry::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.ArraysExtraInfo.Entry.name)
}
inline void ArraysExtraInfo_Entry::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.ArraysExtraInfo.Entry.name)
}
inline std::string* ArraysExtraInfo_Entry::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ArraysExtraInfo_Entry::release_name() {
  // @@protoc_insertion_point(field_release:toco.ArraysExtraInfo.Entry.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ArraysExtraInfo_Entry::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.ArraysExtraInfo.Entry.name)
}

// optional string name_regexp = 7;
inline bool ArraysExtraInfo_Entry::_internal_has_name_regexp() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ArraysExtraInfo_Entry::has_name_regexp() const {
  return _internal_has_name_regexp();
}
inline void ArraysExtraInfo_Entry::clear_name_regexp() {
  name_regexp_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ArraysExtraInfo_Entry::name_regexp() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.name_regexp)
  return _internal_name_regexp();
}
inline void ArraysExtraInfo_Entry::set_name_regexp(const std::string& value) {
  _internal_set_name_regexp(value);
  // @@protoc_insertion_point(field_set:toco.ArraysExtraInfo.Entry.name_regexp)
}
inline std::string* ArraysExtraInfo_Entry::mutable_name_regexp() {
  // @@protoc_insertion_point(field_mutable:toco.ArraysExtraInfo.Entry.name_regexp)
  return _internal_mutable_name_regexp();
}
inline const std::string& ArraysExtraInfo_Entry::_internal_name_regexp() const {
  return name_regexp_.Get();
}
inline void ArraysExtraInfo_Entry::_internal_set_name_regexp(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  name_regexp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ArraysExtraInfo_Entry::set_name_regexp(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  name_regexp_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.ArraysExtraInfo.Entry.name_regexp)
}
inline void ArraysExtraInfo_Entry::set_name_regexp(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  name_regexp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.ArraysExtraInfo.Entry.name_regexp)
}
inline void ArraysExtraInfo_Entry::set_name_regexp(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  name_regexp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.ArraysExtraInfo.Entry.name_regexp)
}
inline std::string* ArraysExtraInfo_Entry::_internal_mutable_name_regexp() {
  _has_bits_[0] |= 0x00000002u;
  return name_regexp_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ArraysExtraInfo_Entry::release_name_regexp() {
  // @@protoc_insertion_point(field_release:toco.ArraysExtraInfo.Entry.name_regexp)
  if (!_internal_has_name_regexp()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return name_regexp_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ArraysExtraInfo_Entry::set_allocated_name_regexp(std::string* name_regexp) {
  if (name_regexp != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  name_regexp_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name_regexp,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.ArraysExtraInfo.Entry.name_regexp)
}

// optional double min = 2;
inline bool ArraysExtraInfo_Entry::_internal_has_min() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ArraysExtraInfo_Entry::has_min() const {
  return _internal_has_min();
}
inline void ArraysExtraInfo_Entry::clear_min() {
  min_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double ArraysExtraInfo_Entry::_internal_min() const {
  return min_;
}
inline double ArraysExtraInfo_Entry::min() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.min)
  return _internal_min();
}
inline void ArraysExtraInfo_Entry::_internal_set_min(double value) {
  _has_bits_[0] |= 0x00000008u;
  min_ = value;
}
inline void ArraysExtraInfo_Entry::set_min(double value) {
  _internal_set_min(value);
  // @@protoc_insertion_point(field_set:toco.ArraysExtraInfo.Entry.min)
}

// optional double max = 3;
inline bool ArraysExtraInfo_Entry::_internal_has_max() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ArraysExtraInfo_Entry::has_max() const {
  return _internal_has_max();
}
inline void ArraysExtraInfo_Entry::clear_max() {
  max_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double ArraysExtraInfo_Entry::_internal_max() const {
  return max_;
}
inline double ArraysExtraInfo_Entry::max() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.max)
  return _internal_max();
}
inline void ArraysExtraInfo_Entry::_internal_set_max(double value) {
  _has_bits_[0] |= 0x00000010u;
  max_ = value;
}
inline void ArraysExtraInfo_Entry::set_max(double value) {
  _internal_set_max(value);
  // @@protoc_insertion_point(field_set:toco.ArraysExtraInfo.Entry.max)
}

// optional .toco.IODataType data_type = 4;
inline bool ArraysExtraInfo_Entry::_internal_has_data_type() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ArraysExtraInfo_Entry::has_data_type() const {
  return _internal_has_data_type();
}
inline void ArraysExtraInfo_Entry::clear_data_type() {
  data_type_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::toco::IODataType ArraysExtraInfo_Entry::_internal_data_type() const {
  return static_cast< ::toco::IODataType >(data_type_);
}
inline ::toco::IODataType ArraysExtraInfo_Entry::data_type() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.data_type)
  return _internal_data_type();
}
inline void ArraysExtraInfo_Entry::_internal_set_data_type(::toco::IODataType value) {
  assert(::toco::IODataType_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  data_type_ = value;
}
inline void ArraysExtraInfo_Entry::set_data_type(::toco::IODataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:toco.ArraysExtraInfo.Entry.data_type)
}

// optional .toco.InputArrayShape shape = 5;
inline bool ArraysExtraInfo_Entry::_internal_has_shape() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || shape_ != nullptr);
  return value;
}
inline bool ArraysExtraInfo_Entry::has_shape() const {
  return _internal_has_shape();
}
inline void ArraysExtraInfo_Entry::clear_shape() {
  if (shape_ != nullptr) shape_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::toco::InputArrayShape& ArraysExtraInfo_Entry::_internal_shape() const {
  const ::toco::InputArrayShape* p = shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::toco::InputArrayShape&>(
      ::toco::_InputArrayShape_default_instance_);
}
inline const ::toco::InputArrayShape& ArraysExtraInfo_Entry::shape() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.shape)
  return _internal_shape();
}
inline void ArraysExtraInfo_Entry::unsafe_arena_set_allocated_shape(
    ::toco::InputArrayShape* shape) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
  }
  shape_ = shape;
  if (shape) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:toco.ArraysExtraInfo.Entry.shape)
}
inline ::toco::InputArrayShape* ArraysExtraInfo_Entry::release_shape() {
  _has_bits_[0] &= ~0x00000004u;
  ::toco::InputArrayShape* temp = shape_;
  shape_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::toco::InputArrayShape* ArraysExtraInfo_Entry::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:toco.ArraysExtraInfo.Entry.shape)
  _has_bits_[0] &= ~0x00000004u;
  ::toco::InputArrayShape* temp = shape_;
  shape_ = nullptr;
  return temp;
}
inline ::toco::InputArrayShape* ArraysExtraInfo_Entry::_internal_mutable_shape() {
  _has_bits_[0] |= 0x00000004u;
  if (shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::toco::InputArrayShape>(GetArena());
    shape_ = p;
  }
  return shape_;
}
inline ::toco::InputArrayShape* ArraysExtraInfo_Entry::mutable_shape() {
  // @@protoc_insertion_point(field_mutable:toco.ArraysExtraInfo.Entry.shape)
  return _internal_mutable_shape();
}
inline void ArraysExtraInfo_Entry::set_allocated_shape(::toco::InputArrayShape* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete shape_;
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:toco.ArraysExtraInfo.Entry.shape)
}

// optional float constant_float_value = 6;
inline bool ArraysExtraInfo_Entry::_internal_has_constant_float_value() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ArraysExtraInfo_Entry::has_constant_float_value() const {
  return _internal_has_constant_float_value();
}
inline void ArraysExtraInfo_Entry::clear_constant_float_value() {
  constant_float_value_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline float ArraysExtraInfo_Entry::_internal_constant_float_value() const {
  return constant_float_value_;
}
inline float ArraysExtraInfo_Entry::constant_float_value() const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.Entry.constant_float_value)
  return _internal_constant_float_value();
}
inline void ArraysExtraInfo_Entry::_internal_set_constant_float_value(float value) {
  _has_bits_[0] |= 0x00000040u;
  constant_float_value_ = value;
}
inline void ArraysExtraInfo_Entry::set_constant_float_value(float value) {
  _internal_set_constant_float_value(value);
  // @@protoc_insertion_point(field_set:toco.ArraysExtraInfo.Entry.constant_float_value)
}

// -------------------------------------------------------------------

// ArraysExtraInfo

// repeated .toco.ArraysExtraInfo.Entry entries = 1;
inline int ArraysExtraInfo::_internal_entries_size() const {
  return entries_.size();
}
inline int ArraysExtraInfo::entries_size() const {
  return _internal_entries_size();
}
inline void ArraysExtraInfo::clear_entries() {
  entries_.Clear();
}
inline ::toco::ArraysExtraInfo_Entry* ArraysExtraInfo::mutable_entries(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ArraysExtraInfo.entries)
  return entries_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ArraysExtraInfo_Entry >*
ArraysExtraInfo::mutable_entries() {
  // @@protoc_insertion_point(field_mutable_list:toco.ArraysExtraInfo.entries)
  return &entries_;
}
inline const ::toco::ArraysExtraInfo_Entry& ArraysExtraInfo::_internal_entries(int index) const {
  return entries_.Get(index);
}
inline const ::toco::ArraysExtraInfo_Entry& ArraysExtraInfo::entries(int index) const {
  // @@protoc_insertion_point(field_get:toco.ArraysExtraInfo.entries)
  return _internal_entries(index);
}
inline ::toco::ArraysExtraInfo_Entry* ArraysExtraInfo::_internal_add_entries() {
  return entries_.Add();
}
inline ::toco::ArraysExtraInfo_Entry* ArraysExtraInfo::add_entries() {
  // @@protoc_insertion_point(field_add:toco.ArraysExtraInfo.entries)
  return _internal_add_entries();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ArraysExtraInfo_Entry >&
ArraysExtraInfo::entries() const {
  // @@protoc_insertion_point(field_list:toco.ArraysExtraInfo.entries)
  return entries_;
}

// -------------------------------------------------------------------

// ModelFlags_ModelCheck

// optional string count_type = 1 [default = "None"];
inline bool ModelFlags_ModelCheck::_internal_has_count_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ModelFlags_ModelCheck::has_count_type() const {
  return _internal_has_count_type();
}
inline void ModelFlags_ModelCheck::clear_count_type() {
  count_type_.ClearToDefault(::toco::ModelFlags_ModelCheck::_i_give_permission_to_break_this_code_default_count_type_, GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ModelFlags_ModelCheck::count_type() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.ModelCheck.count_type)
  if (count_type_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_count_type_.get();
  return _internal_count_type();
}
inline void ModelFlags_ModelCheck::set_count_type(const std::string& value) {
  _internal_set_count_type(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.ModelCheck.count_type)
}
inline std::string* ModelFlags_ModelCheck::mutable_count_type() {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.ModelCheck.count_type)
  return _internal_mutable_count_type();
}
inline const std::string& ModelFlags_ModelCheck::_internal_count_type() const {
  return count_type_.Get();
}
inline void ModelFlags_ModelCheck::_internal_set_count_type(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  count_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArena());
}
inline void ModelFlags_ModelCheck::set_count_type(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  count_type_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.ModelFlags.ModelCheck.count_type)
}
inline void ModelFlags_ModelCheck::set_count_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  count_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.ModelFlags.ModelCheck.count_type)
}
inline void ModelFlags_ModelCheck::set_count_type(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  count_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.ModelFlags.ModelCheck.count_type)
}
inline std::string* ModelFlags_ModelCheck::_internal_mutable_count_type() {
  _has_bits_[0] |= 0x00000001u;
  return count_type_.Mutable(::toco::ModelFlags_ModelCheck::_i_give_permission_to_break_this_code_default_count_type_, GetArena());
}
inline std::string* ModelFlags_ModelCheck::release_count_type() {
  // @@protoc_insertion_point(field_release:toco.ModelFlags.ModelCheck.count_type)
  if (!_internal_has_count_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return count_type_.ReleaseNonDefault(nullptr, GetArena());
}
inline void ModelFlags_ModelCheck::set_allocated_count_type(std::string* count_type) {
  if (count_type != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  count_type_.SetAllocated(nullptr, count_type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.ModelFlags.ModelCheck.count_type)
}

// optional int32 count_min = 2 [default = -1];
inline bool ModelFlags_ModelCheck::_internal_has_count_min() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ModelFlags_ModelCheck::has_count_min() const {
  return _internal_has_count_min();
}
inline void ModelFlags_ModelCheck::clear_count_min() {
  count_min_ = -1;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ModelFlags_ModelCheck::_internal_count_min() const {
  return count_min_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ModelFlags_ModelCheck::count_min() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.ModelCheck.count_min)
  return _internal_count_min();
}
inline void ModelFlags_ModelCheck::_internal_set_count_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  count_min_ = value;
}
inline void ModelFlags_ModelCheck::set_count_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_count_min(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.ModelCheck.count_min)
}

// optional int32 count_max = 3 [default = -1];
inline bool ModelFlags_ModelCheck::_internal_has_count_max() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ModelFlags_ModelCheck::has_count_max() const {
  return _internal_has_count_max();
}
inline void ModelFlags_ModelCheck::clear_count_max() {
  count_max_ = -1;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ModelFlags_ModelCheck::_internal_count_max() const {
  return count_max_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ModelFlags_ModelCheck::count_max() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.ModelCheck.count_max)
  return _internal_count_max();
}
inline void ModelFlags_ModelCheck::_internal_set_count_max(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  count_max_ = value;
}
inline void ModelFlags_ModelCheck::set_count_max(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_count_max(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.ModelCheck.count_max)
}

// -------------------------------------------------------------------

// ModelFlags

// repeated .toco.InputArray input_arrays = 1;
inline int ModelFlags::_internal_input_arrays_size() const {
  return input_arrays_.size();
}
inline int ModelFlags::input_arrays_size() const {
  return _internal_input_arrays_size();
}
inline void ModelFlags::clear_input_arrays() {
  input_arrays_.Clear();
}
inline ::toco::InputArray* ModelFlags::mutable_input_arrays(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.input_arrays)
  return input_arrays_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::InputArray >*
ModelFlags::mutable_input_arrays() {
  // @@protoc_insertion_point(field_mutable_list:toco.ModelFlags.input_arrays)
  return &input_arrays_;
}
inline const ::toco::InputArray& ModelFlags::_internal_input_arrays(int index) const {
  return input_arrays_.Get(index);
}
inline const ::toco::InputArray& ModelFlags::input_arrays(int index) const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.input_arrays)
  return _internal_input_arrays(index);
}
inline ::toco::InputArray* ModelFlags::_internal_add_input_arrays() {
  return input_arrays_.Add();
}
inline ::toco::InputArray* ModelFlags::add_input_arrays() {
  // @@protoc_insertion_point(field_add:toco.ModelFlags.input_arrays)
  return _internal_add_input_arrays();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::InputArray >&
ModelFlags::input_arrays() const {
  // @@protoc_insertion_point(field_list:toco.ModelFlags.input_arrays)
  return input_arrays_;
}

// repeated string output_arrays = 2;
inline int ModelFlags::_internal_output_arrays_size() const {
  return output_arrays_.size();
}
inline int ModelFlags::output_arrays_size() const {
  return _internal_output_arrays_size();
}
inline void ModelFlags::clear_output_arrays() {
  output_arrays_.Clear();
}
inline std::string* ModelFlags::add_output_arrays() {
  // @@protoc_insertion_point(field_add_mutable:toco.ModelFlags.output_arrays)
  return _internal_add_output_arrays();
}
inline const std::string& ModelFlags::_internal_output_arrays(int index) const {
  return output_arrays_.Get(index);
}
inline const std::string& ModelFlags::output_arrays(int index) const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.output_arrays)
  return _internal_output_arrays(index);
}
inline std::string* ModelFlags::mutable_output_arrays(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.output_arrays)
  return output_arrays_.Mutable(index);
}
inline void ModelFlags::set_output_arrays(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:toco.ModelFlags.output_arrays)
  output_arrays_.Mutable(index)->assign(value);
}
inline void ModelFlags::set_output_arrays(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:toco.ModelFlags.output_arrays)
  output_arrays_.Mutable(index)->assign(std::move(value));
}
inline void ModelFlags::set_output_arrays(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  output_arrays_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:toco.ModelFlags.output_arrays)
}
inline void ModelFlags::set_output_arrays(int index, const char* value, size_t size) {
  output_arrays_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:toco.ModelFlags.output_arrays)
}
inline std::string* ModelFlags::_internal_add_output_arrays() {
  return output_arrays_.Add();
}
inline void ModelFlags::add_output_arrays(const std::string& value) {
  output_arrays_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:toco.ModelFlags.output_arrays)
}
inline void ModelFlags::add_output_arrays(std::string&& value) {
  output_arrays_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:toco.ModelFlags.output_arrays)
}
inline void ModelFlags::add_output_arrays(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  output_arrays_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:toco.ModelFlags.output_arrays)
}
inline void ModelFlags::add_output_arrays(const char* value, size_t size) {
  output_arrays_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:toco.ModelFlags.output_arrays)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ModelFlags::output_arrays() const {
  // @@protoc_insertion_point(field_list:toco.ModelFlags.output_arrays)
  return output_arrays_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ModelFlags::mutable_output_arrays() {
  // @@protoc_insertion_point(field_mutable_list:toco.ModelFlags.output_arrays)
  return &output_arrays_;
}

// optional bool variable_batch = 10;
inline bool ModelFlags::_internal_has_variable_batch() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ModelFlags::has_variable_batch() const {
  return _internal_has_variable_batch();
}
inline void ModelFlags::clear_variable_batch() {
  variable_batch_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool ModelFlags::_internal_variable_batch() const {
  return variable_batch_;
}
inline bool ModelFlags::variable_batch() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.variable_batch)
  return _internal_variable_batch();
}
inline void ModelFlags::_internal_set_variable_batch(bool value) {
  _has_bits_[0] |= 0x00000004u;
  variable_batch_ = value;
}
inline void ModelFlags::set_variable_batch(bool value) {
  _internal_set_variable_batch(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.variable_batch)
}

// repeated .toco.RnnState rnn_states = 12;
inline int ModelFlags::_internal_rnn_states_size() const {
  return rnn_states_.size();
}
inline int ModelFlags::rnn_states_size() const {
  return _internal_rnn_states_size();
}
inline void ModelFlags::clear_rnn_states() {
  rnn_states_.Clear();
}
inline ::toco::RnnState* ModelFlags::mutable_rnn_states(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.rnn_states)
  return rnn_states_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::RnnState >*
ModelFlags::mutable_rnn_states() {
  // @@protoc_insertion_point(field_mutable_list:toco.ModelFlags.rnn_states)
  return &rnn_states_;
}
inline const ::toco::RnnState& ModelFlags::_internal_rnn_states(int index) const {
  return rnn_states_.Get(index);
}
inline const ::toco::RnnState& ModelFlags::rnn_states(int index) const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.rnn_states)
  return _internal_rnn_states(index);
}
inline ::toco::RnnState* ModelFlags::_internal_add_rnn_states() {
  return rnn_states_.Add();
}
inline ::toco::RnnState* ModelFlags::add_rnn_states() {
  // @@protoc_insertion_point(field_add:toco.ModelFlags.rnn_states)
  return _internal_add_rnn_states();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::RnnState >&
ModelFlags::rnn_states() const {
  // @@protoc_insertion_point(field_list:toco.ModelFlags.rnn_states)
  return rnn_states_;
}

// repeated .toco.ModelFlags.ModelCheck model_checks = 14;
inline int ModelFlags::_internal_model_checks_size() const {
  return model_checks_.size();
}
inline int ModelFlags::model_checks_size() const {
  return _internal_model_checks_size();
}
inline void ModelFlags::clear_model_checks() {
  model_checks_.Clear();
}
inline ::toco::ModelFlags_ModelCheck* ModelFlags::mutable_model_checks(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.model_checks)
  return model_checks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ModelFlags_ModelCheck >*
ModelFlags::mutable_model_checks() {
  // @@protoc_insertion_point(field_mutable_list:toco.ModelFlags.model_checks)
  return &model_checks_;
}
inline const ::toco::ModelFlags_ModelCheck& ModelFlags::_internal_model_checks(int index) const {
  return model_checks_.Get(index);
}
inline const ::toco::ModelFlags_ModelCheck& ModelFlags::model_checks(int index) const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.model_checks)
  return _internal_model_checks(index);
}
inline ::toco::ModelFlags_ModelCheck* ModelFlags::_internal_add_model_checks() {
  return model_checks_.Add();
}
inline ::toco::ModelFlags_ModelCheck* ModelFlags::add_model_checks() {
  // @@protoc_insertion_point(field_add:toco.ModelFlags.model_checks)
  return _internal_add_model_checks();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::toco::ModelFlags_ModelCheck >&
ModelFlags::model_checks() const {
  // @@protoc_insertion_point(field_list:toco.ModelFlags.model_checks)
  return model_checks_;
}

// optional bool allow_nonexistent_arrays = 16;
inline bool ModelFlags::_internal_has_allow_nonexistent_arrays() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ModelFlags::has_allow_nonexistent_arrays() const {
  return _internal_has_allow_nonexistent_arrays();
}
inline void ModelFlags::clear_allow_nonexistent_arrays() {
  allow_nonexistent_arrays_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool ModelFlags::_internal_allow_nonexistent_arrays() const {
  return allow_nonexistent_arrays_;
}
inline bool ModelFlags::allow_nonexistent_arrays() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.allow_nonexistent_arrays)
  return _internal_allow_nonexistent_arrays();
}
inline void ModelFlags::_internal_set_allow_nonexistent_arrays(bool value) {
  _has_bits_[0] |= 0x00000008u;
  allow_nonexistent_arrays_ = value;
}
inline void ModelFlags::set_allow_nonexistent_arrays(bool value) {
  _internal_set_allow_nonexistent_arrays(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.allow_nonexistent_arrays)
}

// optional bool allow_nonascii_arrays = 17;
inline bool ModelFlags::_internal_has_allow_nonascii_arrays() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ModelFlags::has_allow_nonascii_arrays() const {
  return _internal_has_allow_nonascii_arrays();
}
inline void ModelFlags::clear_allow_nonascii_arrays() {
  allow_nonascii_arrays_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool ModelFlags::_internal_allow_nonascii_arrays() const {
  return allow_nonascii_arrays_;
}
inline bool ModelFlags::allow_nonascii_arrays() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.allow_nonascii_arrays)
  return _internal_allow_nonascii_arrays();
}
inline void ModelFlags::_internal_set_allow_nonascii_arrays(bool value) {
  _has_bits_[0] |= 0x00000010u;
  allow_nonascii_arrays_ = value;
}
inline void ModelFlags::set_allow_nonascii_arrays(bool value) {
  _internal_set_allow_nonascii_arrays(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.allow_nonascii_arrays)
}

// optional .toco.ArraysExtraInfo arrays_extra_info = 18;
inline bool ModelFlags::_internal_has_arrays_extra_info() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || arrays_extra_info_ != nullptr);
  return value;
}
inline bool ModelFlags::has_arrays_extra_info() const {
  return _internal_has_arrays_extra_info();
}
inline void ModelFlags::clear_arrays_extra_info() {
  if (arrays_extra_info_ != nullptr) arrays_extra_info_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::toco::ArraysExtraInfo& ModelFlags::_internal_arrays_extra_info() const {
  const ::toco::ArraysExtraInfo* p = arrays_extra_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::toco::ArraysExtraInfo&>(
      ::toco::_ArraysExtraInfo_default_instance_);
}
inline const ::toco::ArraysExtraInfo& ModelFlags::arrays_extra_info() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.arrays_extra_info)
  return _internal_arrays_extra_info();
}
inline void ModelFlags::unsafe_arena_set_allocated_arrays_extra_info(
    ::toco::ArraysExtraInfo* arrays_extra_info) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arrays_extra_info_);
  }
  arrays_extra_info_ = arrays_extra_info;
  if (arrays_extra_info) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:toco.ModelFlags.arrays_extra_info)
}
inline ::toco::ArraysExtraInfo* ModelFlags::release_arrays_extra_info() {
  _has_bits_[0] &= ~0x00000002u;
  ::toco::ArraysExtraInfo* temp = arrays_extra_info_;
  arrays_extra_info_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::toco::ArraysExtraInfo* ModelFlags::unsafe_arena_release_arrays_extra_info() {
  // @@protoc_insertion_point(field_release:toco.ModelFlags.arrays_extra_info)
  _has_bits_[0] &= ~0x00000002u;
  ::toco::ArraysExtraInfo* temp = arrays_extra_info_;
  arrays_extra_info_ = nullptr;
  return temp;
}
inline ::toco::ArraysExtraInfo* ModelFlags::_internal_mutable_arrays_extra_info() {
  _has_bits_[0] |= 0x00000002u;
  if (arrays_extra_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::toco::ArraysExtraInfo>(GetArena());
    arrays_extra_info_ = p;
  }
  return arrays_extra_info_;
}
inline ::toco::ArraysExtraInfo* ModelFlags::mutable_arrays_extra_info() {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.arrays_extra_info)
  return _internal_mutable_arrays_extra_info();
}
inline void ModelFlags::set_allocated_arrays_extra_info(::toco::ArraysExtraInfo* arrays_extra_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete arrays_extra_info_;
  }
  if (arrays_extra_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arrays_extra_info);
    if (message_arena != submessage_arena) {
      arrays_extra_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, arrays_extra_info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  arrays_extra_info_ = arrays_extra_info;
  // @@protoc_insertion_point(field_set_allocated:toco.ModelFlags.arrays_extra_info)
}

// optional bool change_concat_input_ranges = 19 [default = true];
inline bool ModelFlags::_internal_has_change_concat_input_ranges() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ModelFlags::has_change_concat_input_ranges() const {
  return _internal_has_change_concat_input_ranges();
}
inline void ModelFlags::clear_change_concat_input_ranges() {
  change_concat_input_ranges_ = true;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool ModelFlags::_internal_change_concat_input_ranges() const {
  return change_concat_input_ranges_;
}
inline bool ModelFlags::change_concat_input_ranges() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.change_concat_input_ranges)
  return _internal_change_concat_input_ranges();
}
inline void ModelFlags::_internal_set_change_concat_input_ranges(bool value) {
  _has_bits_[0] |= 0x00000040u;
  change_concat_input_ranges_ = value;
}
inline void ModelFlags::set_change_concat_input_ranges(bool value) {
  _internal_set_change_concat_input_ranges(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.change_concat_input_ranges)
}

// optional string saved_model_dir = 20;
inline bool ModelFlags::_internal_has_saved_model_dir() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ModelFlags::has_saved_model_dir() const {
  return _internal_has_saved_model_dir();
}
inline void ModelFlags::clear_saved_model_dir() {
  saved_model_dir_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ModelFlags::saved_model_dir() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.saved_model_dir)
  return _internal_saved_model_dir();
}
inline void ModelFlags::set_saved_model_dir(const std::string& value) {
  _internal_set_saved_model_dir(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.saved_model_dir)
}
inline std::string* ModelFlags::mutable_saved_model_dir() {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.saved_model_dir)
  return _internal_mutable_saved_model_dir();
}
inline const std::string& ModelFlags::_internal_saved_model_dir() const {
  return saved_model_dir_.Get();
}
inline void ModelFlags::_internal_set_saved_model_dir(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  saved_model_dir_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ModelFlags::set_saved_model_dir(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  saved_model_dir_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:toco.ModelFlags.saved_model_dir)
}
inline void ModelFlags::set_saved_model_dir(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  saved_model_dir_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:toco.ModelFlags.saved_model_dir)
}
inline void ModelFlags::set_saved_model_dir(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  saved_model_dir_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:toco.ModelFlags.saved_model_dir)
}
inline std::string* ModelFlags::_internal_mutable_saved_model_dir() {
  _has_bits_[0] |= 0x00000001u;
  return saved_model_dir_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ModelFlags::release_saved_model_dir() {
  // @@protoc_insertion_point(field_release:toco.ModelFlags.saved_model_dir)
  if (!_internal_has_saved_model_dir()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return saved_model_dir_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ModelFlags::set_allocated_saved_model_dir(std::string* saved_model_dir) {
  if (saved_model_dir != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  saved_model_dir_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), saved_model_dir,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:toco.ModelFlags.saved_model_dir)
}

// optional int32 saved_model_version = 21;
inline bool ModelFlags::_internal_has_saved_model_version() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ModelFlags::has_saved_model_version() const {
  return _internal_has_saved_model_version();
}
inline void ModelFlags::clear_saved_model_version() {
  saved_model_version_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ModelFlags::_internal_saved_model_version() const {
  return saved_model_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ModelFlags::saved_model_version() const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.saved_model_version)
  return _internal_saved_model_version();
}
inline void ModelFlags::_internal_set_saved_model_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000020u;
  saved_model_version_ = value;
}
inline void ModelFlags::set_saved_model_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_saved_model_version(value);
  // @@protoc_insertion_point(field_set:toco.ModelFlags.saved_model_version)
}

// repeated string saved_model_tags = 22;
inline int ModelFlags::_internal_saved_model_tags_size() const {
  return saved_model_tags_.size();
}
inline int ModelFlags::saved_model_tags_size() const {
  return _internal_saved_model_tags_size();
}
inline void ModelFlags::clear_saved_model_tags() {
  saved_model_tags_.Clear();
}
inline std::string* ModelFlags::add_saved_model_tags() {
  // @@protoc_insertion_point(field_add_mutable:toco.ModelFlags.saved_model_tags)
  return _internal_add_saved_model_tags();
}
inline const std::string& ModelFlags::_internal_saved_model_tags(int index) const {
  return saved_model_tags_.Get(index);
}
inline const std::string& ModelFlags::saved_model_tags(int index) const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.saved_model_tags)
  return _internal_saved_model_tags(index);
}
inline std::string* ModelFlags::mutable_saved_model_tags(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.saved_model_tags)
  return saved_model_tags_.Mutable(index);
}
inline void ModelFlags::set_saved_model_tags(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:toco.ModelFlags.saved_model_tags)
  saved_model_tags_.Mutable(index)->assign(value);
}
inline void ModelFlags::set_saved_model_tags(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:toco.ModelFlags.saved_model_tags)
  saved_model_tags_.Mutable(index)->assign(std::move(value));
}
inline void ModelFlags::set_saved_model_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  saved_model_tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:toco.ModelFlags.saved_model_tags)
}
inline void ModelFlags::set_saved_model_tags(int index, const char* value, size_t size) {
  saved_model_tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:toco.ModelFlags.saved_model_tags)
}
inline std::string* ModelFlags::_internal_add_saved_model_tags() {
  return saved_model_tags_.Add();
}
inline void ModelFlags::add_saved_model_tags(const std::string& value) {
  saved_model_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:toco.ModelFlags.saved_model_tags)
}
inline void ModelFlags::add_saved_model_tags(std::string&& value) {
  saved_model_tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:toco.ModelFlags.saved_model_tags)
}
inline void ModelFlags::add_saved_model_tags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  saved_model_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:toco.ModelFlags.saved_model_tags)
}
inline void ModelFlags::add_saved_model_tags(const char* value, size_t size) {
  saved_model_tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:toco.ModelFlags.saved_model_tags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ModelFlags::saved_model_tags() const {
  // @@protoc_insertion_point(field_list:toco.ModelFlags.saved_model_tags)
  return saved_model_tags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ModelFlags::mutable_saved_model_tags() {
  // @@protoc_insertion_point(field_mutable_list:toco.ModelFlags.saved_model_tags)
  return &saved_model_tags_;
}

// repeated string saved_model_exported_names = 23;
inline int ModelFlags::_internal_saved_model_exported_names_size() const {
  return saved_model_exported_names_.size();
}
inline int ModelFlags::saved_model_exported_names_size() const {
  return _internal_saved_model_exported_names_size();
}
inline void ModelFlags::clear_saved_model_exported_names() {
  saved_model_exported_names_.Clear();
}
inline std::string* ModelFlags::add_saved_model_exported_names() {
  // @@protoc_insertion_point(field_add_mutable:toco.ModelFlags.saved_model_exported_names)
  return _internal_add_saved_model_exported_names();
}
inline const std::string& ModelFlags::_internal_saved_model_exported_names(int index) const {
  return saved_model_exported_names_.Get(index);
}
inline const std::string& ModelFlags::saved_model_exported_names(int index) const {
  // @@protoc_insertion_point(field_get:toco.ModelFlags.saved_model_exported_names)
  return _internal_saved_model_exported_names(index);
}
inline std::string* ModelFlags::mutable_saved_model_exported_names(int index) {
  // @@protoc_insertion_point(field_mutable:toco.ModelFlags.saved_model_exported_names)
  return saved_model_exported_names_.Mutable(index);
}
inline void ModelFlags::set_saved_model_exported_names(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:toco.ModelFlags.saved_model_exported_names)
  saved_model_exported_names_.Mutable(index)->assign(value);
}
inline void ModelFlags::set_saved_model_exported_names(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:toco.ModelFlags.saved_model_exported_names)
  saved_model_exported_names_.Mutable(index)->assign(std::move(value));
}
inline void ModelFlags::set_saved_model_exported_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  saved_model_exported_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:toco.ModelFlags.saved_model_exported_names)
}
inline void ModelFlags::set_saved_model_exported_names(int index, const char* value, size_t size) {
  saved_model_exported_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:toco.ModelFlags.saved_model_exported_names)
}
inline std::string* ModelFlags::_internal_add_saved_model_exported_names() {
  return saved_model_exported_names_.Add();
}
inline void ModelFlags::add_saved_model_exported_names(const std::string& value) {
  saved_model_exported_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:toco.ModelFlags.saved_model_exported_names)
}
inline void ModelFlags::add_saved_model_exported_names(std::string&& value) {
  saved_model_exported_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:toco.ModelFlags.saved_model_exported_names)
}
inline void ModelFlags::add_saved_model_exported_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  saved_model_exported_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:toco.ModelFlags.saved_model_exported_names)
}
inline void ModelFlags::add_saved_model_exported_names(const char* value, size_t size) {
  saved_model_exported_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:toco.ModelFlags.saved_model_exported_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ModelFlags::saved_model_exported_names() const {
  // @@protoc_insertion_point(field_list:toco.ModelFlags.saved_model_exported_names)
  return saved_model_exported_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ModelFlags::mutable_saved_model_exported_names() {
  // @@protoc_insertion_point(field_mutable_list:toco.ModelFlags.saved_model_exported_names)
  return &saved_model_exported_names_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace toco

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2flite_2ftoco_2fmodel_5fflags_2eproto
