// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: MNN_compression.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_MNN_5fcompression_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_MNN_5fcompression_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#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 3019000 < 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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_MNN_5fcompression_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_MNN_5fcompression_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[11]
    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 uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_MNN_5fcompression_2eproto;
namespace MNN {
namespace Compression {
class CompressionAlgo;
struct CompressionAlgoDefaultTypeInternal;
extern CompressionAlgoDefaultTypeInternal _CompressionAlgo_default_instance_;
class LayerQuantizeParams;
struct LayerQuantizeParamsDefaultTypeInternal;
extern LayerQuantizeParamsDefaultTypeInternal _LayerQuantizeParams_default_instance_;
class LayerQuantizeParams_ActivationParams;
struct LayerQuantizeParams_ActivationParamsDefaultTypeInternal;
extern LayerQuantizeParams_ActivationParamsDefaultTypeInternal _LayerQuantizeParams_ActivationParams_default_instance_;
class LayerQuantizeParams_ConvolutionInfo;
struct LayerQuantizeParams_ConvolutionInfoDefaultTypeInternal;
extern LayerQuantizeParams_ConvolutionInfoDefaultTypeInternal _LayerQuantizeParams_ConvolutionInfo_default_instance_;
class LayerQuantizeParams_WeightParams;
struct LayerQuantizeParams_WeightParamsDefaultTypeInternal;
extern LayerQuantizeParams_WeightParamsDefaultTypeInternal _LayerQuantizeParams_WeightParams_default_instance_;
class LayerQuantizeParams_WinogradParams;
struct LayerQuantizeParams_WinogradParamsDefaultTypeInternal;
extern LayerQuantizeParams_WinogradParamsDefaultTypeInternal _LayerQuantizeParams_WinogradParams_default_instance_;
class LevelPrunerParams;
struct LevelPrunerParamsDefaultTypeInternal;
extern LevelPrunerParamsDefaultTypeInternal _LevelPrunerParams_default_instance_;
class Pipeline;
struct PipelineDefaultTypeInternal;
extern PipelineDefaultTypeInternal _Pipeline_default_instance_;
class PruneParams;
struct PruneParamsDefaultTypeInternal;
extern PruneParamsDefaultTypeInternal _PruneParams_default_instance_;
class QuantizeParams;
struct QuantizeParamsDefaultTypeInternal;
extern QuantizeParamsDefaultTypeInternal _QuantizeParams_default_instance_;
class SIMDOCPrunerParams;
struct SIMDOCPrunerParamsDefaultTypeInternal;
extern SIMDOCPrunerParamsDefaultTypeInternal _SIMDOCPrunerParams_default_instance_;
}  // namespace Compression
}  // namespace MNN
PROTOBUF_NAMESPACE_OPEN
template<> ::MNN::Compression::CompressionAlgo* Arena::CreateMaybeMessage<::MNN::Compression::CompressionAlgo>(Arena*);
template<> ::MNN::Compression::LayerQuantizeParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams>(Arena*);
template<> ::MNN::Compression::LayerQuantizeParams_ActivationParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_ActivationParams>(Arena*);
template<> ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_ConvolutionInfo>(Arena*);
template<> ::MNN::Compression::LayerQuantizeParams_WeightParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_WeightParams>(Arena*);
template<> ::MNN::Compression::LayerQuantizeParams_WinogradParams* Arena::CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_WinogradParams>(Arena*);
template<> ::MNN::Compression::LevelPrunerParams* Arena::CreateMaybeMessage<::MNN::Compression::LevelPrunerParams>(Arena*);
template<> ::MNN::Compression::Pipeline* Arena::CreateMaybeMessage<::MNN::Compression::Pipeline>(Arena*);
template<> ::MNN::Compression::PruneParams* Arena::CreateMaybeMessage<::MNN::Compression::PruneParams>(Arena*);
template<> ::MNN::Compression::QuantizeParams* Arena::CreateMaybeMessage<::MNN::Compression::QuantizeParams>(Arena*);
template<> ::MNN::Compression::SIMDOCPrunerParams* Arena::CreateMaybeMessage<::MNN::Compression::SIMDOCPrunerParams>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace MNN {
namespace Compression {

enum QuantizeParams_RoundMode : int {
  QuantizeParams_RoundMode_ROUND_TOWARDS_ZERO = 0,
  QuantizeParams_RoundMode_ROUND_AWAY_FROM_ZERO = 1,
  QuantizeParams_RoundMode_ROUND_HALF_TO_EVEN = 2
};
bool QuantizeParams_RoundMode_IsValid(int value);
constexpr QuantizeParams_RoundMode QuantizeParams_RoundMode_RoundMode_MIN = QuantizeParams_RoundMode_ROUND_TOWARDS_ZERO;
constexpr QuantizeParams_RoundMode QuantizeParams_RoundMode_RoundMode_MAX = QuantizeParams_RoundMode_ROUND_HALF_TO_EVEN;
constexpr int QuantizeParams_RoundMode_RoundMode_ARRAYSIZE = QuantizeParams_RoundMode_RoundMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QuantizeParams_RoundMode_descriptor();
template<typename T>
inline const std::string& QuantizeParams_RoundMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, QuantizeParams_RoundMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function QuantizeParams_RoundMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    QuantizeParams_RoundMode_descriptor(), enum_t_value);
}
inline bool QuantizeParams_RoundMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QuantizeParams_RoundMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<QuantizeParams_RoundMode>(
    QuantizeParams_RoundMode_descriptor(), name, value);
}
enum LayerQuantizeParams_QuantMethod : int {
  LayerQuantizeParams_QuantMethod_QAT = 0,
  LayerQuantizeParams_QuantMethod_OverflowAware = 1,
  LayerQuantizeParams_QuantMethod_WinogradAware = 2
};
bool LayerQuantizeParams_QuantMethod_IsValid(int value);
constexpr LayerQuantizeParams_QuantMethod LayerQuantizeParams_QuantMethod_QuantMethod_MIN = LayerQuantizeParams_QuantMethod_QAT;
constexpr LayerQuantizeParams_QuantMethod LayerQuantizeParams_QuantMethod_QuantMethod_MAX = LayerQuantizeParams_QuantMethod_WinogradAware;
constexpr int LayerQuantizeParams_QuantMethod_QuantMethod_ARRAYSIZE = LayerQuantizeParams_QuantMethod_QuantMethod_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LayerQuantizeParams_QuantMethod_descriptor();
template<typename T>
inline const std::string& LayerQuantizeParams_QuantMethod_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LayerQuantizeParams_QuantMethod>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LayerQuantizeParams_QuantMethod_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LayerQuantizeParams_QuantMethod_descriptor(), enum_t_value);
}
inline bool LayerQuantizeParams_QuantMethod_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LayerQuantizeParams_QuantMethod* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LayerQuantizeParams_QuantMethod>(
    LayerQuantizeParams_QuantMethod_descriptor(), name, value);
}
enum PruneParams_PruneType : int {
  PruneParams_PruneType_RANDOM = 0,
  PruneParams_PruneType_SIMD_OC = 1,
  PruneParams_PruneType_FILTER = 2
};
bool PruneParams_PruneType_IsValid(int value);
constexpr PruneParams_PruneType PruneParams_PruneType_PruneType_MIN = PruneParams_PruneType_RANDOM;
constexpr PruneParams_PruneType PruneParams_PruneType_PruneType_MAX = PruneParams_PruneType_FILTER;
constexpr int PruneParams_PruneType_PruneType_ARRAYSIZE = PruneParams_PruneType_PruneType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PruneParams_PruneType_descriptor();
template<typename T>
inline const std::string& PruneParams_PruneType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PruneParams_PruneType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PruneParams_PruneType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PruneParams_PruneType_descriptor(), enum_t_value);
}
inline bool PruneParams_PruneType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PruneParams_PruneType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PruneParams_PruneType>(
    PruneParams_PruneType_descriptor(), name, value);
}
enum CompressionAlgo_CompressionType : int {
  CompressionAlgo_CompressionType_QUANTIZE = 0,
  CompressionAlgo_CompressionType_PRUNE = 1
};
bool CompressionAlgo_CompressionType_IsValid(int value);
constexpr CompressionAlgo_CompressionType CompressionAlgo_CompressionType_CompressionType_MIN = CompressionAlgo_CompressionType_QUANTIZE;
constexpr CompressionAlgo_CompressionType CompressionAlgo_CompressionType_CompressionType_MAX = CompressionAlgo_CompressionType_PRUNE;
constexpr int CompressionAlgo_CompressionType_CompressionType_ARRAYSIZE = CompressionAlgo_CompressionType_CompressionType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompressionAlgo_CompressionType_descriptor();
template<typename T>
inline const std::string& CompressionAlgo_CompressionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CompressionAlgo_CompressionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CompressionAlgo_CompressionType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CompressionAlgo_CompressionType_descriptor(), enum_t_value);
}
inline bool CompressionAlgo_CompressionType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressionAlgo_CompressionType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CompressionAlgo_CompressionType>(
    CompressionAlgo_CompressionType_descriptor(), name, value);
}
// ===================================================================

class QuantizeParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.QuantizeParams) */ {
 public:
  inline QuantizeParams() : QuantizeParams(nullptr) {}
  ~QuantizeParams() override;
  explicit constexpr QuantizeParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline QuantizeParams& operator=(const QuantizeParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline QuantizeParams& operator=(QuantizeParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const QuantizeParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const QuantizeParams* internal_default_instance() {
    return reinterpret_cast<const QuantizeParams*>(
               &_QuantizeParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(QuantizeParams& a, QuantizeParams& b) {
    a.Swap(&b);
  }
  inline void Swap(QuantizeParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(QuantizeParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  QuantizeParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<QuantizeParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const QuantizeParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const QuantizeParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(QuantizeParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.QuantizeParams";
  }
  protected:
  explicit QuantizeParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef QuantizeParams_RoundMode RoundMode;
  static constexpr RoundMode ROUND_TOWARDS_ZERO =
    QuantizeParams_RoundMode_ROUND_TOWARDS_ZERO;
  static constexpr RoundMode ROUND_AWAY_FROM_ZERO =
    QuantizeParams_RoundMode_ROUND_AWAY_FROM_ZERO;
  static constexpr RoundMode ROUND_HALF_TO_EVEN =
    QuantizeParams_RoundMode_ROUND_HALF_TO_EVEN;
  static inline bool RoundMode_IsValid(int value) {
    return QuantizeParams_RoundMode_IsValid(value);
  }
  static constexpr RoundMode RoundMode_MIN =
    QuantizeParams_RoundMode_RoundMode_MIN;
  static constexpr RoundMode RoundMode_MAX =
    QuantizeParams_RoundMode_RoundMode_MAX;
  static constexpr int RoundMode_ARRAYSIZE =
    QuantizeParams_RoundMode_RoundMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RoundMode_descriptor() {
    return QuantizeParams_RoundMode_descriptor();
  }
  template<typename T>
  static inline const std::string& RoundMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RoundMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RoundMode_Name.");
    return QuantizeParams_RoundMode_Name(enum_t_value);
  }
  static inline bool RoundMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RoundMode* value) {
    return QuantizeParams_RoundMode_Parse(name, value);
  }

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

  enum : int {
    kLayerFieldNumber = 4,
    kRoundModeFieldNumber = 1,
  };
  // repeated .MNN.Compression.LayerQuantizeParams layer = 4;
  int layer_size() const;
  private:
  int _internal_layer_size() const;
  public:
  void clear_layer();
  ::MNN::Compression::LayerQuantizeParams* mutable_layer(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >*
      mutable_layer();
  private:
  const ::MNN::Compression::LayerQuantizeParams& _internal_layer(int index) const;
  ::MNN::Compression::LayerQuantizeParams* _internal_add_layer();
  public:
  const ::MNN::Compression::LayerQuantizeParams& layer(int index) const;
  ::MNN::Compression::LayerQuantizeParams* add_layer();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >&
      layer() const;

  // optional .MNN.Compression.QuantizeParams.RoundMode round_mode = 1 [default = ROUND_AWAY_FROM_ZERO];
  bool has_round_mode() const;
  private:
  bool _internal_has_round_mode() const;
  public:
  void clear_round_mode();
  ::MNN::Compression::QuantizeParams_RoundMode round_mode() const;
  void set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value);
  private:
  ::MNN::Compression::QuantizeParams_RoundMode _internal_round_mode() const;
  void _internal_set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.QuantizeParams)
 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< ::MNN::Compression::LayerQuantizeParams > layer_;
  int round_mode_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class LayerQuantizeParams_ActivationParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.ActivationParams) */ {
 public:
  inline LayerQuantizeParams_ActivationParams() : LayerQuantizeParams_ActivationParams(nullptr) {}
  ~LayerQuantizeParams_ActivationParams() override;
  explicit constexpr LayerQuantizeParams_ActivationParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LayerQuantizeParams_ActivationParams& operator=(const LayerQuantizeParams_ActivationParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerQuantizeParams_ActivationParams& operator=(LayerQuantizeParams_ActivationParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LayerQuantizeParams_ActivationParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const LayerQuantizeParams_ActivationParams* internal_default_instance() {
    return reinterpret_cast<const LayerQuantizeParams_ActivationParams*>(
               &_LayerQuantizeParams_ActivationParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(LayerQuantizeParams_ActivationParams& a, LayerQuantizeParams_ActivationParams& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerQuantizeParams_ActivationParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LayerQuantizeParams_ActivationParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LayerQuantizeParams_ActivationParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LayerQuantizeParams_ActivationParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LayerQuantizeParams_ActivationParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LayerQuantizeParams_ActivationParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerQuantizeParams_ActivationParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.LayerQuantizeParams.ActivationParams";
  }
  protected:
  explicit LayerQuantizeParams_ActivationParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kScalesFieldNumber = 3,
    kNameFieldNumber = 1,
    kZeroPointFieldNumber = 4,
    kClampMaxFieldNumber = 6,
    kBitsFieldNumber = 2,
    kClampMinFieldNumber = 5,
  };
  // repeated float scales = 3;
  int scales_size() const;
  private:
  int _internal_scales_size() const;
  public:
  void clear_scales();
  private:
  float _internal_scales(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_scales() const;
  void _internal_add_scales(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_scales();
  public:
  float scales(int index) const;
  void set_scales(int index, float value);
  void add_scales(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      scales() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_scales();

  // required string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional int32 zero_point = 4 [default = 0];
  bool has_zero_point() const;
  private:
  bool _internal_has_zero_point() const;
  public:
  void clear_zero_point();
  int32_t zero_point() const;
  void set_zero_point(int32_t value);
  private:
  int32_t _internal_zero_point() const;
  void _internal_set_zero_point(int32_t value);
  public:

  // optional int32 clamp_max = 6 [default = 127];
  bool has_clamp_max() const;
  private:
  bool _internal_has_clamp_max() const;
  public:
  void clear_clamp_max();
  int32_t clamp_max() const;
  void set_clamp_max(int32_t value);
  private:
  int32_t _internal_clamp_max() const;
  void _internal_set_clamp_max(int32_t value);
  public:

  // optional int32 bits = 2 [default = 8];
  bool has_bits() const;
  private:
  bool _internal_has_bits() const;
  public:
  void clear_bits();
  int32_t bits() const;
  void set_bits(int32_t value);
  private:
  int32_t _internal_bits() const;
  void _internal_set_bits(int32_t value);
  public:

  // optional int32 clamp_min = 5 [default = -128];
  bool has_clamp_min() const;
  private:
  bool _internal_has_clamp_min() const;
  public:
  void clear_clamp_min();
  int32_t clamp_min() const;
  void set_clamp_min(int32_t value);
  private:
  int32_t _internal_clamp_min() const;
  void _internal_set_clamp_min(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.ActivationParams)
 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::RepeatedField< float > scales_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  int32_t zero_point_;
  int32_t clamp_max_;
  int32_t bits_;
  int32_t clamp_min_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class LayerQuantizeParams_WeightParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.WeightParams) */ {
 public:
  inline LayerQuantizeParams_WeightParams() : LayerQuantizeParams_WeightParams(nullptr) {}
  ~LayerQuantizeParams_WeightParams() override;
  explicit constexpr LayerQuantizeParams_WeightParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LayerQuantizeParams_WeightParams& operator=(const LayerQuantizeParams_WeightParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerQuantizeParams_WeightParams& operator=(LayerQuantizeParams_WeightParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LayerQuantizeParams_WeightParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const LayerQuantizeParams_WeightParams* internal_default_instance() {
    return reinterpret_cast<const LayerQuantizeParams_WeightParams*>(
               &_LayerQuantizeParams_WeightParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(LayerQuantizeParams_WeightParams& a, LayerQuantizeParams_WeightParams& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerQuantizeParams_WeightParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LayerQuantizeParams_WeightParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LayerQuantizeParams_WeightParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LayerQuantizeParams_WeightParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LayerQuantizeParams_WeightParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LayerQuantizeParams_WeightParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerQuantizeParams_WeightParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.LayerQuantizeParams.WeightParams";
  }
  protected:
  explicit LayerQuantizeParams_WeightParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kScalesFieldNumber = 3,
    kNameFieldNumber = 1,
    kAsymmetricFieldNumber = 6,
    kBlockSizeFieldNumber = 7,
    kClampMaxFieldNumber = 5,
    kBitsFieldNumber = 2,
    kClampMinFieldNumber = 4,
  };
  // repeated float scales = 3;
  int scales_size() const;
  private:
  int _internal_scales_size() const;
  public:
  void clear_scales();
  private:
  float _internal_scales(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_scales() const;
  void _internal_add_scales(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_scales();
  public:
  float scales(int index) const;
  void set_scales(int index, float value);
  void add_scales(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      scales() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_scales();

  // required string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional bool asymmetric = 6 [default = false];
  bool has_asymmetric() const;
  private:
  bool _internal_has_asymmetric() const;
  public:
  void clear_asymmetric();
  bool asymmetric() const;
  void set_asymmetric(bool value);
  private:
  bool _internal_asymmetric() const;
  void _internal_set_asymmetric(bool value);
  public:

  // optional int32 block_size = 7 [default = 0];
  bool has_block_size() const;
  private:
  bool _internal_has_block_size() const;
  public:
  void clear_block_size();
  int32_t block_size() const;
  void set_block_size(int32_t value);
  private:
  int32_t _internal_block_size() const;
  void _internal_set_block_size(int32_t value);
  public:

  // optional int32 clamp_max = 5 [default = 127];
  bool has_clamp_max() const;
  private:
  bool _internal_has_clamp_max() const;
  public:
  void clear_clamp_max();
  int32_t clamp_max() const;
  void set_clamp_max(int32_t value);
  private:
  int32_t _internal_clamp_max() const;
  void _internal_set_clamp_max(int32_t value);
  public:

  // optional int32 bits = 2 [default = 8];
  bool has_bits() const;
  private:
  bool _internal_has_bits() const;
  public:
  void clear_bits();
  int32_t bits() const;
  void set_bits(int32_t value);
  private:
  int32_t _internal_bits() const;
  void _internal_set_bits(int32_t value);
  public:

  // optional int32 clamp_min = 4 [default = -128];
  bool has_clamp_min() const;
  private:
  bool _internal_has_clamp_min() const;
  public:
  void clear_clamp_min();
  int32_t clamp_min() const;
  void set_clamp_min(int32_t value);
  private:
  int32_t _internal_clamp_min() const;
  void _internal_set_clamp_min(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.WeightParams)
 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::RepeatedField< float > scales_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  bool asymmetric_;
  int32_t block_size_;
  int32_t clamp_max_;
  int32_t bits_;
  int32_t clamp_min_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class LayerQuantizeParams_WinogradParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.WinogradParams) */ {
 public:
  inline LayerQuantizeParams_WinogradParams() : LayerQuantizeParams_WinogradParams(nullptr) {}
  ~LayerQuantizeParams_WinogradParams() override;
  explicit constexpr LayerQuantizeParams_WinogradParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LayerQuantizeParams_WinogradParams& operator=(const LayerQuantizeParams_WinogradParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerQuantizeParams_WinogradParams& operator=(LayerQuantizeParams_WinogradParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LayerQuantizeParams_WinogradParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const LayerQuantizeParams_WinogradParams* internal_default_instance() {
    return reinterpret_cast<const LayerQuantizeParams_WinogradParams*>(
               &_LayerQuantizeParams_WinogradParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(LayerQuantizeParams_WinogradParams& a, LayerQuantizeParams_WinogradParams& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerQuantizeParams_WinogradParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LayerQuantizeParams_WinogradParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LayerQuantizeParams_WinogradParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LayerQuantizeParams_WinogradParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LayerQuantizeParams_WinogradParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LayerQuantizeParams_WinogradParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerQuantizeParams_WinogradParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.LayerQuantizeParams.WinogradParams";
  }
  protected:
  explicit LayerQuantizeParams_WinogradParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kUnitsAttrFieldNumber = 4,
    kVersionFieldNumber = 1,
  };
  // repeated int32 units_attr = 4;
  int units_attr_size() const;
  private:
  int _internal_units_attr_size() const;
  public:
  void clear_units_attr();
  private:
  int32_t _internal_units_attr(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_units_attr() const;
  void _internal_add_units_attr(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_units_attr();
  public:
  int32_t units_attr(int index) const;
  void set_units_attr(int index, int32_t value);
  void add_units_attr(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      units_attr() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_units_attr();

  // required int32 version = 1 [default = 0];
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.WinogradParams)
 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::RepeatedField< int32_t > units_attr_;
  int32_t version_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class LayerQuantizeParams_ConvolutionInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams.ConvolutionInfo) */ {
 public:
  inline LayerQuantizeParams_ConvolutionInfo() : LayerQuantizeParams_ConvolutionInfo(nullptr) {}
  ~LayerQuantizeParams_ConvolutionInfo() override;
  explicit constexpr LayerQuantizeParams_ConvolutionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LayerQuantizeParams_ConvolutionInfo& operator=(const LayerQuantizeParams_ConvolutionInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerQuantizeParams_ConvolutionInfo& operator=(LayerQuantizeParams_ConvolutionInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LayerQuantizeParams_ConvolutionInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const LayerQuantizeParams_ConvolutionInfo* internal_default_instance() {
    return reinterpret_cast<const LayerQuantizeParams_ConvolutionInfo*>(
               &_LayerQuantizeParams_ConvolutionInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(LayerQuantizeParams_ConvolutionInfo& a, LayerQuantizeParams_ConvolutionInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerQuantizeParams_ConvolutionInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LayerQuantizeParams_ConvolutionInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LayerQuantizeParams_ConvolutionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LayerQuantizeParams_ConvolutionInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LayerQuantizeParams_ConvolutionInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LayerQuantizeParams_ConvolutionInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerQuantizeParams_ConvolutionInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.LayerQuantizeParams.ConvolutionInfo";
  }
  protected:
  explicit LayerQuantizeParams_ConvolutionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kKernelSizeFieldNumber = 3,
    kInputChannelFieldNumber = 1,
    kOutputChannelFieldNumber = 2,
  };
  // repeated int32 kernel_size = 3;
  int kernel_size_size() const;
  private:
  int _internal_kernel_size_size() const;
  public:
  void clear_kernel_size();
  private:
  int32_t _internal_kernel_size(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_kernel_size() const;
  void _internal_add_kernel_size(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_kernel_size();
  public:
  int32_t kernel_size(int index) const;
  void set_kernel_size(int index, int32_t value);
  void add_kernel_size(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      kernel_size() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_kernel_size();

  // required int32 input_channel = 1;
  bool has_input_channel() const;
  private:
  bool _internal_has_input_channel() const;
  public:
  void clear_input_channel();
  int32_t input_channel() const;
  void set_input_channel(int32_t value);
  private:
  int32_t _internal_input_channel() const;
  void _internal_set_input_channel(int32_t value);
  public:

  // required int32 output_channel = 2;
  bool has_output_channel() const;
  private:
  bool _internal_has_output_channel() const;
  public:
  void clear_output_channel();
  int32_t output_channel() const;
  void set_output_channel(int32_t value);
  private:
  int32_t _internal_output_channel() const;
  void _internal_set_output_channel(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams.ConvolutionInfo)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  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::RepeatedField< int32_t > kernel_size_;
  int32_t input_channel_;
  int32_t output_channel_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class LayerQuantizeParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LayerQuantizeParams) */ {
 public:
  inline LayerQuantizeParams() : LayerQuantizeParams(nullptr) {}
  ~LayerQuantizeParams() override;
  explicit constexpr LayerQuantizeParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LayerQuantizeParams& operator=(const LayerQuantizeParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerQuantizeParams& operator=(LayerQuantizeParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LayerQuantizeParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const LayerQuantizeParams* internal_default_instance() {
    return reinterpret_cast<const LayerQuantizeParams*>(
               &_LayerQuantizeParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(LayerQuantizeParams& a, LayerQuantizeParams& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerQuantizeParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LayerQuantizeParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LayerQuantizeParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LayerQuantizeParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LayerQuantizeParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LayerQuantizeParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerQuantizeParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.LayerQuantizeParams";
  }
  protected:
  explicit LayerQuantizeParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef LayerQuantizeParams_ActivationParams ActivationParams;
  typedef LayerQuantizeParams_WeightParams WeightParams;
  typedef LayerQuantizeParams_WinogradParams WinogradParams;
  typedef LayerQuantizeParams_ConvolutionInfo ConvolutionInfo;

  typedef LayerQuantizeParams_QuantMethod QuantMethod;
  static constexpr QuantMethod QAT =
    LayerQuantizeParams_QuantMethod_QAT;
  static constexpr QuantMethod OverflowAware =
    LayerQuantizeParams_QuantMethod_OverflowAware;
  static constexpr QuantMethod WinogradAware =
    LayerQuantizeParams_QuantMethod_WinogradAware;
  static inline bool QuantMethod_IsValid(int value) {
    return LayerQuantizeParams_QuantMethod_IsValid(value);
  }
  static constexpr QuantMethod QuantMethod_MIN =
    LayerQuantizeParams_QuantMethod_QuantMethod_MIN;
  static constexpr QuantMethod QuantMethod_MAX =
    LayerQuantizeParams_QuantMethod_QuantMethod_MAX;
  static constexpr int QuantMethod_ARRAYSIZE =
    LayerQuantizeParams_QuantMethod_QuantMethod_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  QuantMethod_descriptor() {
    return LayerQuantizeParams_QuantMethod_descriptor();
  }
  template<typename T>
  static inline const std::string& QuantMethod_Name(T enum_t_value) {
    static_assert(::std::is_same<T, QuantMethod>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function QuantMethod_Name.");
    return LayerQuantizeParams_QuantMethod_Name(enum_t_value);
  }
  static inline bool QuantMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      QuantMethod* value) {
    return LayerQuantizeParams_QuantMethod_Parse(name, value);
  }

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

  enum : int {
    kInputFieldNumber = 1,
    kWeightFieldNumber = 2,
    kOutputFieldNumber = 3,
    kOpNameFieldNumber = 6,
    kSubgraphNameFieldNumber = 7,
    kWinoParamsFieldNumber = 5,
    kConvFieldNumber = 8,
    kMethodFieldNumber = 4,
  };
  // repeated .MNN.Compression.LayerQuantizeParams.ActivationParams input = 1;
  int input_size() const;
  private:
  int _internal_input_size() const;
  public:
  void clear_input();
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* mutable_input(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
      mutable_input();
  private:
  const ::MNN::Compression::LayerQuantizeParams_ActivationParams& _internal_input(int index) const;
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* _internal_add_input();
  public:
  const ::MNN::Compression::LayerQuantizeParams_ActivationParams& input(int index) const;
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* add_input();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
      input() const;

  // repeated .MNN.Compression.LayerQuantizeParams.WeightParams weight = 2;
  int weight_size() const;
  private:
  int _internal_weight_size() const;
  public:
  void clear_weight();
  ::MNN::Compression::LayerQuantizeParams_WeightParams* mutable_weight(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >*
      mutable_weight();
  private:
  const ::MNN::Compression::LayerQuantizeParams_WeightParams& _internal_weight(int index) const;
  ::MNN::Compression::LayerQuantizeParams_WeightParams* _internal_add_weight();
  public:
  const ::MNN::Compression::LayerQuantizeParams_WeightParams& weight(int index) const;
  ::MNN::Compression::LayerQuantizeParams_WeightParams* add_weight();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >&
      weight() const;

  // repeated .MNN.Compression.LayerQuantizeParams.ActivationParams output = 3;
  int output_size() const;
  private:
  int _internal_output_size() const;
  public:
  void clear_output();
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* mutable_output(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
      mutable_output();
  private:
  const ::MNN::Compression::LayerQuantizeParams_ActivationParams& _internal_output(int index) const;
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* _internal_add_output();
  public:
  const ::MNN::Compression::LayerQuantizeParams_ActivationParams& output(int index) const;
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* add_output();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
      output() const;

  // optional string op_name = 6;
  bool has_op_name() const;
  private:
  bool _internal_has_op_name() const;
  public:
  void clear_op_name();
  const std::string& op_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_op_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_op_name();
  PROTOBUF_NODISCARD std::string* release_op_name();
  void set_allocated_op_name(std::string* op_name);
  private:
  const std::string& _internal_op_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_name(const std::string& value);
  std::string* _internal_mutable_op_name();
  public:

  // optional string subgraph_name = 7;
  bool has_subgraph_name() const;
  private:
  bool _internal_has_subgraph_name() const;
  public:
  void clear_subgraph_name();
  const std::string& subgraph_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_subgraph_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_subgraph_name();
  PROTOBUF_NODISCARD std::string* release_subgraph_name();
  void set_allocated_subgraph_name(std::string* subgraph_name);
  private:
  const std::string& _internal_subgraph_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subgraph_name(const std::string& value);
  std::string* _internal_mutable_subgraph_name();
  public:

  // optional .MNN.Compression.LayerQuantizeParams.WinogradParams wino_params = 5;
  bool has_wino_params() const;
  private:
  bool _internal_has_wino_params() const;
  public:
  void clear_wino_params();
  const ::MNN::Compression::LayerQuantizeParams_WinogradParams& wino_params() const;
  PROTOBUF_NODISCARD ::MNN::Compression::LayerQuantizeParams_WinogradParams* release_wino_params();
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* mutable_wino_params();
  void set_allocated_wino_params(::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params);
  private:
  const ::MNN::Compression::LayerQuantizeParams_WinogradParams& _internal_wino_params() const;
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* _internal_mutable_wino_params();
  public:
  void unsafe_arena_set_allocated_wino_params(
      ::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params);
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* unsafe_arena_release_wino_params();

  // optional .MNN.Compression.LayerQuantizeParams.ConvolutionInfo conv = 8;
  bool has_conv() const;
  private:
  bool _internal_has_conv() const;
  public:
  void clear_conv();
  const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& conv() const;
  PROTOBUF_NODISCARD ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* release_conv();
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* mutable_conv();
  void set_allocated_conv(::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv);
  private:
  const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& _internal_conv() const;
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* _internal_mutable_conv();
  public:
  void unsafe_arena_set_allocated_conv(
      ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv);
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* unsafe_arena_release_conv();

  // optional .MNN.Compression.LayerQuantizeParams.QuantMethod method = 4 [default = QAT];
  bool has_method() const;
  private:
  bool _internal_has_method() const;
  public:
  void clear_method();
  ::MNN::Compression::LayerQuantizeParams_QuantMethod method() const;
  void set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value);
  private:
  ::MNN::Compression::LayerQuantizeParams_QuantMethod _internal_method() const;
  void _internal_set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.LayerQuantizeParams)
 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< ::MNN::Compression::LayerQuantizeParams_ActivationParams > input_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams > weight_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams > output_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subgraph_name_;
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params_;
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv_;
  int method_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class LevelPrunerParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.LevelPrunerParams) */ {
 public:
  inline LevelPrunerParams() : LevelPrunerParams(nullptr) {}
  ~LevelPrunerParams() override;
  explicit constexpr LevelPrunerParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LevelPrunerParams& operator=(const LevelPrunerParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline LevelPrunerParams& operator=(LevelPrunerParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LevelPrunerParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const LevelPrunerParams* internal_default_instance() {
    return reinterpret_cast<const LevelPrunerParams*>(
               &_LevelPrunerParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(LevelPrunerParams& a, LevelPrunerParams& b) {
    a.Swap(&b);
  }
  inline void Swap(LevelPrunerParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LevelPrunerParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LevelPrunerParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LevelPrunerParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LevelPrunerParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LevelPrunerParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LevelPrunerParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.LevelPrunerParams";
  }
  protected:
  explicit LevelPrunerParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kWeightTensorNamesFieldNumber = 1,
    kPruneRatiosFieldNumber = 2,
    kLayerNamesFieldNumber = 3,
  };
  // repeated string weight_tensor_names = 1;
  int weight_tensor_names_size() const;
  private:
  int _internal_weight_tensor_names_size() const;
  public:
  void clear_weight_tensor_names();
  const std::string& weight_tensor_names(int index) const;
  std::string* mutable_weight_tensor_names(int index);
  void set_weight_tensor_names(int index, const std::string& value);
  void set_weight_tensor_names(int index, std::string&& value);
  void set_weight_tensor_names(int index, const char* value);
  void set_weight_tensor_names(int index, const char* value, size_t size);
  std::string* add_weight_tensor_names();
  void add_weight_tensor_names(const std::string& value);
  void add_weight_tensor_names(std::string&& value);
  void add_weight_tensor_names(const char* value);
  void add_weight_tensor_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& weight_tensor_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_weight_tensor_names();
  private:
  const std::string& _internal_weight_tensor_names(int index) const;
  std::string* _internal_add_weight_tensor_names();
  public:

  // repeated float prune_ratios = 2;
  int prune_ratios_size() const;
  private:
  int _internal_prune_ratios_size() const;
  public:
  void clear_prune_ratios();
  private:
  float _internal_prune_ratios(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_prune_ratios() const;
  void _internal_add_prune_ratios(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_prune_ratios();
  public:
  float prune_ratios(int index) const;
  void set_prune_ratios(int index, float value);
  void add_prune_ratios(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      prune_ratios() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_prune_ratios();

  // repeated string layer_names = 3;
  int layer_names_size() const;
  private:
  int _internal_layer_names_size() const;
  public:
  void clear_layer_names();
  const std::string& layer_names(int index) const;
  std::string* mutable_layer_names(int index);
  void set_layer_names(int index, const std::string& value);
  void set_layer_names(int index, std::string&& value);
  void set_layer_names(int index, const char* value);
  void set_layer_names(int index, const char* value, size_t size);
  std::string* add_layer_names();
  void add_layer_names(const std::string& value);
  void add_layer_names(std::string&& value);
  void add_layer_names(const char* value);
  void add_layer_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& layer_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_layer_names();
  private:
  const std::string& _internal_layer_names(int index) const;
  std::string* _internal_add_layer_names();
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.LevelPrunerParams)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> weight_tensor_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > prune_ratios_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> layer_names_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class SIMDOCPrunerParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.SIMDOCPrunerParams) */ {
 public:
  inline SIMDOCPrunerParams() : SIMDOCPrunerParams(nullptr) {}
  ~SIMDOCPrunerParams() override;
  explicit constexpr SIMDOCPrunerParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SIMDOCPrunerParams& operator=(const SIMDOCPrunerParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline SIMDOCPrunerParams& operator=(SIMDOCPrunerParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SIMDOCPrunerParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const SIMDOCPrunerParams* internal_default_instance() {
    return reinterpret_cast<const SIMDOCPrunerParams*>(
               &_SIMDOCPrunerParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(SIMDOCPrunerParams& a, SIMDOCPrunerParams& b) {
    a.Swap(&b);
  }
  inline void Swap(SIMDOCPrunerParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SIMDOCPrunerParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SIMDOCPrunerParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SIMDOCPrunerParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SIMDOCPrunerParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SIMDOCPrunerParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SIMDOCPrunerParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.SIMDOCPrunerParams";
  }
  protected:
  explicit SIMDOCPrunerParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kWeightTensorNamesFieldNumber = 1,
    kPruneRatiosFieldNumber = 2,
    kLayerNamesFieldNumber = 3,
    kOcBlocksFieldNumber = 4,
  };
  // repeated string weight_tensor_names = 1;
  int weight_tensor_names_size() const;
  private:
  int _internal_weight_tensor_names_size() const;
  public:
  void clear_weight_tensor_names();
  const std::string& weight_tensor_names(int index) const;
  std::string* mutable_weight_tensor_names(int index);
  void set_weight_tensor_names(int index, const std::string& value);
  void set_weight_tensor_names(int index, std::string&& value);
  void set_weight_tensor_names(int index, const char* value);
  void set_weight_tensor_names(int index, const char* value, size_t size);
  std::string* add_weight_tensor_names();
  void add_weight_tensor_names(const std::string& value);
  void add_weight_tensor_names(std::string&& value);
  void add_weight_tensor_names(const char* value);
  void add_weight_tensor_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& weight_tensor_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_weight_tensor_names();
  private:
  const std::string& _internal_weight_tensor_names(int index) const;
  std::string* _internal_add_weight_tensor_names();
  public:

  // repeated float prune_ratios = 2;
  int prune_ratios_size() const;
  private:
  int _internal_prune_ratios_size() const;
  public:
  void clear_prune_ratios();
  private:
  float _internal_prune_ratios(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_prune_ratios() const;
  void _internal_add_prune_ratios(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_prune_ratios();
  public:
  float prune_ratios(int index) const;
  void set_prune_ratios(int index, float value);
  void add_prune_ratios(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      prune_ratios() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_prune_ratios();

  // repeated string layer_names = 3;
  int layer_names_size() const;
  private:
  int _internal_layer_names_size() const;
  public:
  void clear_layer_names();
  const std::string& layer_names(int index) const;
  std::string* mutable_layer_names(int index);
  void set_layer_names(int index, const std::string& value);
  void set_layer_names(int index, std::string&& value);
  void set_layer_names(int index, const char* value);
  void set_layer_names(int index, const char* value, size_t size);
  std::string* add_layer_names();
  void add_layer_names(const std::string& value);
  void add_layer_names(std::string&& value);
  void add_layer_names(const char* value);
  void add_layer_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& layer_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_layer_names();
  private:
  const std::string& _internal_layer_names(int index) const;
  std::string* _internal_add_layer_names();
  public:

  // repeated int32 oc_blocks = 4;
  int oc_blocks_size() const;
  private:
  int _internal_oc_blocks_size() const;
  public:
  void clear_oc_blocks();
  private:
  int32_t _internal_oc_blocks(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_oc_blocks() const;
  void _internal_add_oc_blocks(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_oc_blocks();
  public:
  int32_t oc_blocks(int index) const;
  void set_oc_blocks(int index, int32_t value);
  void add_oc_blocks(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      oc_blocks() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_oc_blocks();

  // @@protoc_insertion_point(class_scope:MNN.Compression.SIMDOCPrunerParams)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> weight_tensor_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > prune_ratios_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> layer_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > oc_blocks_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class PruneParams final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.PruneParams) */ {
 public:
  inline PruneParams() : PruneParams(nullptr) {}
  ~PruneParams() override;
  explicit constexpr PruneParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PruneParams& operator=(const PruneParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline PruneParams& operator=(PruneParams&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PruneParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const PruneParams* internal_default_instance() {
    return reinterpret_cast<const PruneParams*>(
               &_PruneParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(PruneParams& a, PruneParams& b) {
    a.Swap(&b);
  }
  inline void Swap(PruneParams* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PruneParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PruneParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PruneParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PruneParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PruneParams& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PruneParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.PruneParams";
  }
  protected:
  explicit PruneParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef PruneParams_PruneType PruneType;
  static constexpr PruneType RANDOM =
    PruneParams_PruneType_RANDOM;
  static constexpr PruneType SIMD_OC =
    PruneParams_PruneType_SIMD_OC;
  static constexpr PruneType FILTER =
    PruneParams_PruneType_FILTER;
  static inline bool PruneType_IsValid(int value) {
    return PruneParams_PruneType_IsValid(value);
  }
  static constexpr PruneType PruneType_MIN =
    PruneParams_PruneType_PruneType_MIN;
  static constexpr PruneType PruneType_MAX =
    PruneParams_PruneType_PruneType_MAX;
  static constexpr int PruneType_ARRAYSIZE =
    PruneParams_PruneType_PruneType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PruneType_descriptor() {
    return PruneParams_PruneType_descriptor();
  }
  template<typename T>
  static inline const std::string& PruneType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PruneType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PruneType_Name.");
    return PruneParams_PruneType_Name(enum_t_value);
  }
  static inline bool PruneType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PruneType* value) {
    return PruneParams_PruneType_Parse(name, value);
  }

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

  enum : int {
    kLevelPrunerParamsFieldNumber = 2,
    kSimdOcPrunerParamsFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // optional .MNN.Compression.LevelPrunerParams level_pruner_params = 2;
  bool has_level_pruner_params() const;
  private:
  bool _internal_has_level_pruner_params() const;
  public:
  void clear_level_pruner_params();
  const ::MNN::Compression::LevelPrunerParams& level_pruner_params() const;
  PROTOBUF_NODISCARD ::MNN::Compression::LevelPrunerParams* release_level_pruner_params();
  ::MNN::Compression::LevelPrunerParams* mutable_level_pruner_params();
  void set_allocated_level_pruner_params(::MNN::Compression::LevelPrunerParams* level_pruner_params);
  private:
  const ::MNN::Compression::LevelPrunerParams& _internal_level_pruner_params() const;
  ::MNN::Compression::LevelPrunerParams* _internal_mutable_level_pruner_params();
  public:
  void unsafe_arena_set_allocated_level_pruner_params(
      ::MNN::Compression::LevelPrunerParams* level_pruner_params);
  ::MNN::Compression::LevelPrunerParams* unsafe_arena_release_level_pruner_params();

  // optional .MNN.Compression.SIMDOCPrunerParams simd_oc_pruner_params = 3;
  bool has_simd_oc_pruner_params() const;
  private:
  bool _internal_has_simd_oc_pruner_params() const;
  public:
  void clear_simd_oc_pruner_params();
  const ::MNN::Compression::SIMDOCPrunerParams& simd_oc_pruner_params() const;
  PROTOBUF_NODISCARD ::MNN::Compression::SIMDOCPrunerParams* release_simd_oc_pruner_params();
  ::MNN::Compression::SIMDOCPrunerParams* mutable_simd_oc_pruner_params();
  void set_allocated_simd_oc_pruner_params(::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params);
  private:
  const ::MNN::Compression::SIMDOCPrunerParams& _internal_simd_oc_pruner_params() const;
  ::MNN::Compression::SIMDOCPrunerParams* _internal_mutable_simd_oc_pruner_params();
  public:
  void unsafe_arena_set_allocated_simd_oc_pruner_params(
      ::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params);
  ::MNN::Compression::SIMDOCPrunerParams* unsafe_arena_release_simd_oc_pruner_params();

  // optional .MNN.Compression.PruneParams.PruneType type = 1 [default = RANDOM];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::MNN::Compression::PruneParams_PruneType type() const;
  void set_type(::MNN::Compression::PruneParams_PruneType value);
  private:
  ::MNN::Compression::PruneParams_PruneType _internal_type() const;
  void _internal_set_type(::MNN::Compression::PruneParams_PruneType value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.PruneParams)
 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_;
  ::MNN::Compression::LevelPrunerParams* level_pruner_params_;
  ::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params_;
  int type_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class CompressionAlgo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.CompressionAlgo) */ {
 public:
  inline CompressionAlgo() : CompressionAlgo(nullptr) {}
  ~CompressionAlgo() override;
  explicit constexpr CompressionAlgo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline CompressionAlgo& operator=(const CompressionAlgo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CompressionAlgo& operator=(CompressionAlgo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CompressionAlgo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CompressionAlgo* internal_default_instance() {
    return reinterpret_cast<const CompressionAlgo*>(
               &_CompressionAlgo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CompressionAlgo& a, CompressionAlgo& b) {
    a.Swap(&b);
  }
  inline void Swap(CompressionAlgo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CompressionAlgo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CompressionAlgo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CompressionAlgo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CompressionAlgo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CompressionAlgo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CompressionAlgo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.CompressionAlgo";
  }
  protected:
  explicit CompressionAlgo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef CompressionAlgo_CompressionType CompressionType;
  static constexpr CompressionType QUANTIZE =
    CompressionAlgo_CompressionType_QUANTIZE;
  static constexpr CompressionType PRUNE =
    CompressionAlgo_CompressionType_PRUNE;
  static inline bool CompressionType_IsValid(int value) {
    return CompressionAlgo_CompressionType_IsValid(value);
  }
  static constexpr CompressionType CompressionType_MIN =
    CompressionAlgo_CompressionType_CompressionType_MIN;
  static constexpr CompressionType CompressionType_MAX =
    CompressionAlgo_CompressionType_CompressionType_MAX;
  static constexpr int CompressionType_ARRAYSIZE =
    CompressionAlgo_CompressionType_CompressionType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  CompressionType_descriptor() {
    return CompressionAlgo_CompressionType_descriptor();
  }
  template<typename T>
  static inline const std::string& CompressionType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CompressionType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CompressionType_Name.");
    return CompressionAlgo_CompressionType_Name(enum_t_value);
  }
  static inline bool CompressionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CompressionType* value) {
    return CompressionAlgo_CompressionType_Parse(name, value);
  }

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

  enum : int {
    kQuantParamsFieldNumber = 2,
    kPruneParamsFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // optional .MNN.Compression.QuantizeParams quant_params = 2;
  bool has_quant_params() const;
  private:
  bool _internal_has_quant_params() const;
  public:
  void clear_quant_params();
  const ::MNN::Compression::QuantizeParams& quant_params() const;
  PROTOBUF_NODISCARD ::MNN::Compression::QuantizeParams* release_quant_params();
  ::MNN::Compression::QuantizeParams* mutable_quant_params();
  void set_allocated_quant_params(::MNN::Compression::QuantizeParams* quant_params);
  private:
  const ::MNN::Compression::QuantizeParams& _internal_quant_params() const;
  ::MNN::Compression::QuantizeParams* _internal_mutable_quant_params();
  public:
  void unsafe_arena_set_allocated_quant_params(
      ::MNN::Compression::QuantizeParams* quant_params);
  ::MNN::Compression::QuantizeParams* unsafe_arena_release_quant_params();

  // optional .MNN.Compression.PruneParams prune_params = 3;
  bool has_prune_params() const;
  private:
  bool _internal_has_prune_params() const;
  public:
  void clear_prune_params();
  const ::MNN::Compression::PruneParams& prune_params() const;
  PROTOBUF_NODISCARD ::MNN::Compression::PruneParams* release_prune_params();
  ::MNN::Compression::PruneParams* mutable_prune_params();
  void set_allocated_prune_params(::MNN::Compression::PruneParams* prune_params);
  private:
  const ::MNN::Compression::PruneParams& _internal_prune_params() const;
  ::MNN::Compression::PruneParams* _internal_mutable_prune_params();
  public:
  void unsafe_arena_set_allocated_prune_params(
      ::MNN::Compression::PruneParams* prune_params);
  ::MNN::Compression::PruneParams* unsafe_arena_release_prune_params();

  // optional .MNN.Compression.CompressionAlgo.CompressionType type = 1 [default = QUANTIZE];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::MNN::Compression::CompressionAlgo_CompressionType type() const;
  void set_type(::MNN::Compression::CompressionAlgo_CompressionType value);
  private:
  ::MNN::Compression::CompressionAlgo_CompressionType _internal_type() const;
  void _internal_set_type(::MNN::Compression::CompressionAlgo_CompressionType value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.CompressionAlgo)
 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_;
  ::MNN::Compression::QuantizeParams* quant_params_;
  ::MNN::Compression::PruneParams* prune_params_;
  int type_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// -------------------------------------------------------------------

class Pipeline final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MNN.Compression.Pipeline) */ {
 public:
  inline Pipeline() : Pipeline(nullptr) {}
  ~Pipeline() override;
  explicit constexpr Pipeline(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Pipeline& operator=(const Pipeline& from) {
    CopyFrom(from);
    return *this;
  }
  inline Pipeline& operator=(Pipeline&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Pipeline& default_instance() {
    return *internal_default_instance();
  }
  static inline const Pipeline* internal_default_instance() {
    return reinterpret_cast<const Pipeline*>(
               &_Pipeline_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(Pipeline& a, Pipeline& b) {
    a.Swap(&b);
  }
  inline void Swap(Pipeline* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Pipeline* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Pipeline* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Pipeline>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Pipeline& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Pipeline& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Pipeline* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MNN.Compression.Pipeline";
  }
  protected:
  explicit Pipeline(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kAlgoFieldNumber = 2,
    kVersionFieldNumber = 1,
    kMnnUuidFieldNumber = 3,
    kForGuideFieldNumber = 4,
  };
  // repeated .MNN.Compression.CompressionAlgo algo = 2;
  int algo_size() const;
  private:
  int _internal_algo_size() const;
  public:
  void clear_algo();
  ::MNN::Compression::CompressionAlgo* mutable_algo(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >*
      mutable_algo();
  private:
  const ::MNN::Compression::CompressionAlgo& _internal_algo(int index) const;
  ::MNN::Compression::CompressionAlgo* _internal_add_algo();
  public:
  const ::MNN::Compression::CompressionAlgo& algo(int index) const;
  ::MNN::Compression::CompressionAlgo* add_algo();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >&
      algo() const;

  // required string version = 1 [default = "0.0.0"];
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // optional string mnn_uuid = 3;
  bool has_mnn_uuid() const;
  private:
  bool _internal_has_mnn_uuid() const;
  public:
  void clear_mnn_uuid();
  const std::string& mnn_uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mnn_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mnn_uuid();
  PROTOBUF_NODISCARD std::string* release_mnn_uuid();
  void set_allocated_mnn_uuid(std::string* mnn_uuid);
  private:
  const std::string& _internal_mnn_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mnn_uuid(const std::string& value);
  std::string* _internal_mutable_mnn_uuid();
  public:

  // optional bool for_guide = 4 [default = false];
  bool has_for_guide() const;
  private:
  bool _internal_has_for_guide() const;
  public:
  void clear_for_guide();
  bool for_guide() const;
  void set_for_guide(bool value);
  private:
  bool _internal_for_guide() const;
  void _internal_set_for_guide(bool value);
  public:

  // @@protoc_insertion_point(class_scope:MNN.Compression.Pipeline)
 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< ::MNN::Compression::CompressionAlgo > algo_;
  static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mnn_uuid_;
  bool for_guide_;
  friend struct ::TableStruct_MNN_5fcompression_2eproto;
};
// ===================================================================


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

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

// optional .MNN.Compression.QuantizeParams.RoundMode round_mode = 1 [default = ROUND_AWAY_FROM_ZERO];
inline bool QuantizeParams::_internal_has_round_mode() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool QuantizeParams::has_round_mode() const {
  return _internal_has_round_mode();
}
inline void QuantizeParams::clear_round_mode() {
  round_mode_ = 1;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::MNN::Compression::QuantizeParams_RoundMode QuantizeParams::_internal_round_mode() const {
  return static_cast< ::MNN::Compression::QuantizeParams_RoundMode >(round_mode_);
}
inline ::MNN::Compression::QuantizeParams_RoundMode QuantizeParams::round_mode() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.QuantizeParams.round_mode)
  return _internal_round_mode();
}
inline void QuantizeParams::_internal_set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value) {
  assert(::MNN::Compression::QuantizeParams_RoundMode_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  round_mode_ = value;
}
inline void QuantizeParams::set_round_mode(::MNN::Compression::QuantizeParams_RoundMode value) {
  _internal_set_round_mode(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.QuantizeParams.round_mode)
}

// repeated .MNN.Compression.LayerQuantizeParams layer = 4;
inline int QuantizeParams::_internal_layer_size() const {
  return layer_.size();
}
inline int QuantizeParams::layer_size() const {
  return _internal_layer_size();
}
inline void QuantizeParams::clear_layer() {
  layer_.Clear();
}
inline ::MNN::Compression::LayerQuantizeParams* QuantizeParams::mutable_layer(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.QuantizeParams.layer)
  return layer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >*
QuantizeParams::mutable_layer() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.QuantizeParams.layer)
  return &layer_;
}
inline const ::MNN::Compression::LayerQuantizeParams& QuantizeParams::_internal_layer(int index) const {
  return layer_.Get(index);
}
inline const ::MNN::Compression::LayerQuantizeParams& QuantizeParams::layer(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.QuantizeParams.layer)
  return _internal_layer(index);
}
inline ::MNN::Compression::LayerQuantizeParams* QuantizeParams::_internal_add_layer() {
  return layer_.Add();
}
inline ::MNN::Compression::LayerQuantizeParams* QuantizeParams::add_layer() {
  ::MNN::Compression::LayerQuantizeParams* _add = _internal_add_layer();
  // @@protoc_insertion_point(field_add:MNN.Compression.QuantizeParams.layer)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams >&
QuantizeParams::layer() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.QuantizeParams.layer)
  return layer_;
}

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

// LayerQuantizeParams_ActivationParams

// required string name = 1;
inline bool LayerQuantizeParams_ActivationParams::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ActivationParams::has_name() const {
  return _internal_has_name();
}
inline void LayerQuantizeParams_ActivationParams::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LayerQuantizeParams_ActivationParams::name() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerQuantizeParams_ActivationParams::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
}
inline std::string* LayerQuantizeParams_ActivationParams::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
  return _s;
}
inline const std::string& LayerQuantizeParams_ActivationParams::_internal_name() const {
  return name_.Get();
}
inline void LayerQuantizeParams_ActivationParams::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams_ActivationParams::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams_ActivationParams::release_name() {
  // @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LayerQuantizeParams_ActivationParams::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,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.ActivationParams.name)
}

// optional int32 bits = 2 [default = 8];
inline bool LayerQuantizeParams_ActivationParams::_internal_has_bits() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ActivationParams::has_bits() const {
  return _internal_has_bits();
}
inline void LayerQuantizeParams_ActivationParams::clear_bits() {
  bits_ = 8;
  _has_bits_[0] &= ~0x00000008u;
}
inline int32_t LayerQuantizeParams_ActivationParams::_internal_bits() const {
  return bits_;
}
inline int32_t LayerQuantizeParams_ActivationParams::bits() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.bits)
  return _internal_bits();
}
inline void LayerQuantizeParams_ActivationParams::_internal_set_bits(int32_t value) {
  _has_bits_[0] |= 0x00000008u;
  bits_ = value;
}
inline void LayerQuantizeParams_ActivationParams::set_bits(int32_t value) {
  _internal_set_bits(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.bits)
}

// repeated float scales = 3;
inline int LayerQuantizeParams_ActivationParams::_internal_scales_size() const {
  return scales_.size();
}
inline int LayerQuantizeParams_ActivationParams::scales_size() const {
  return _internal_scales_size();
}
inline void LayerQuantizeParams_ActivationParams::clear_scales() {
  scales_.Clear();
}
inline float LayerQuantizeParams_ActivationParams::_internal_scales(int index) const {
  return scales_.Get(index);
}
inline float LayerQuantizeParams_ActivationParams::scales(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
  return _internal_scales(index);
}
inline void LayerQuantizeParams_ActivationParams::set_scales(int index, float value) {
  scales_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
}
inline void LayerQuantizeParams_ActivationParams::_internal_add_scales(float value) {
  scales_.Add(value);
}
inline void LayerQuantizeParams_ActivationParams::add_scales(float value) {
  _internal_add_scales(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerQuantizeParams_ActivationParams::_internal_scales() const {
  return scales_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerQuantizeParams_ActivationParams::scales() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
  return _internal_scales();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerQuantizeParams_ActivationParams::_internal_mutable_scales() {
  return &scales_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerQuantizeParams_ActivationParams::mutable_scales() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.ActivationParams.scales)
  return _internal_mutable_scales();
}

// optional int32 zero_point = 4 [default = 0];
inline bool LayerQuantizeParams_ActivationParams::_internal_has_zero_point() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ActivationParams::has_zero_point() const {
  return _internal_has_zero_point();
}
inline void LayerQuantizeParams_ActivationParams::clear_zero_point() {
  zero_point_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline int32_t LayerQuantizeParams_ActivationParams::_internal_zero_point() const {
  return zero_point_;
}
inline int32_t LayerQuantizeParams_ActivationParams::zero_point() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.zero_point)
  return _internal_zero_point();
}
inline void LayerQuantizeParams_ActivationParams::_internal_set_zero_point(int32_t value) {
  _has_bits_[0] |= 0x00000002u;
  zero_point_ = value;
}
inline void LayerQuantizeParams_ActivationParams::set_zero_point(int32_t value) {
  _internal_set_zero_point(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.zero_point)
}

// optional int32 clamp_min = 5 [default = -128];
inline bool LayerQuantizeParams_ActivationParams::_internal_has_clamp_min() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ActivationParams::has_clamp_min() const {
  return _internal_has_clamp_min();
}
inline void LayerQuantizeParams_ActivationParams::clear_clamp_min() {
  clamp_min_ = -128;
  _has_bits_[0] &= ~0x00000010u;
}
inline int32_t LayerQuantizeParams_ActivationParams::_internal_clamp_min() const {
  return clamp_min_;
}
inline int32_t LayerQuantizeParams_ActivationParams::clamp_min() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_min)
  return _internal_clamp_min();
}
inline void LayerQuantizeParams_ActivationParams::_internal_set_clamp_min(int32_t value) {
  _has_bits_[0] |= 0x00000010u;
  clamp_min_ = value;
}
inline void LayerQuantizeParams_ActivationParams::set_clamp_min(int32_t value) {
  _internal_set_clamp_min(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_min)
}

// optional int32 clamp_max = 6 [default = 127];
inline bool LayerQuantizeParams_ActivationParams::_internal_has_clamp_max() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ActivationParams::has_clamp_max() const {
  return _internal_has_clamp_max();
}
inline void LayerQuantizeParams_ActivationParams::clear_clamp_max() {
  clamp_max_ = 127;
  _has_bits_[0] &= ~0x00000004u;
}
inline int32_t LayerQuantizeParams_ActivationParams::_internal_clamp_max() const {
  return clamp_max_;
}
inline int32_t LayerQuantizeParams_ActivationParams::clamp_max() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_max)
  return _internal_clamp_max();
}
inline void LayerQuantizeParams_ActivationParams::_internal_set_clamp_max(int32_t value) {
  _has_bits_[0] |= 0x00000004u;
  clamp_max_ = value;
}
inline void LayerQuantizeParams_ActivationParams::set_clamp_max(int32_t value) {
  _internal_set_clamp_max(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ActivationParams.clamp_max)
}

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

// LayerQuantizeParams_WeightParams

// required string name = 1;
inline bool LayerQuantizeParams_WeightParams::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WeightParams::has_name() const {
  return _internal_has_name();
}
inline void LayerQuantizeParams_WeightParams::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LayerQuantizeParams_WeightParams::name() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerQuantizeParams_WeightParams::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.name)
}
inline std::string* LayerQuantizeParams_WeightParams::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.WeightParams.name)
  return _s;
}
inline const std::string& LayerQuantizeParams_WeightParams::_internal_name() const {
  return name_.Get();
}
inline void LayerQuantizeParams_WeightParams::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams_WeightParams::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams_WeightParams::release_name() {
  // @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.WeightParams.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LayerQuantizeParams_WeightParams::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,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.WeightParams.name)
}

// optional int32 bits = 2 [default = 8];
inline bool LayerQuantizeParams_WeightParams::_internal_has_bits() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WeightParams::has_bits() const {
  return _internal_has_bits();
}
inline void LayerQuantizeParams_WeightParams::clear_bits() {
  bits_ = 8;
  _has_bits_[0] &= ~0x00000010u;
}
inline int32_t LayerQuantizeParams_WeightParams::_internal_bits() const {
  return bits_;
}
inline int32_t LayerQuantizeParams_WeightParams::bits() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.bits)
  return _internal_bits();
}
inline void LayerQuantizeParams_WeightParams::_internal_set_bits(int32_t value) {
  _has_bits_[0] |= 0x00000010u;
  bits_ = value;
}
inline void LayerQuantizeParams_WeightParams::set_bits(int32_t value) {
  _internal_set_bits(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.bits)
}

// repeated float scales = 3;
inline int LayerQuantizeParams_WeightParams::_internal_scales_size() const {
  return scales_.size();
}
inline int LayerQuantizeParams_WeightParams::scales_size() const {
  return _internal_scales_size();
}
inline void LayerQuantizeParams_WeightParams::clear_scales() {
  scales_.Clear();
}
inline float LayerQuantizeParams_WeightParams::_internal_scales(int index) const {
  return scales_.Get(index);
}
inline float LayerQuantizeParams_WeightParams::scales(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
  return _internal_scales(index);
}
inline void LayerQuantizeParams_WeightParams::set_scales(int index, float value) {
  scales_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
}
inline void LayerQuantizeParams_WeightParams::_internal_add_scales(float value) {
  scales_.Add(value);
}
inline void LayerQuantizeParams_WeightParams::add_scales(float value) {
  _internal_add_scales(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerQuantizeParams_WeightParams::_internal_scales() const {
  return scales_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerQuantizeParams_WeightParams::scales() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
  return _internal_scales();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerQuantizeParams_WeightParams::_internal_mutable_scales() {
  return &scales_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerQuantizeParams_WeightParams::mutable_scales() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.WeightParams.scales)
  return _internal_mutable_scales();
}

// optional int32 clamp_min = 4 [default = -128];
inline bool LayerQuantizeParams_WeightParams::_internal_has_clamp_min() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WeightParams::has_clamp_min() const {
  return _internal_has_clamp_min();
}
inline void LayerQuantizeParams_WeightParams::clear_clamp_min() {
  clamp_min_ = -128;
  _has_bits_[0] &= ~0x00000020u;
}
inline int32_t LayerQuantizeParams_WeightParams::_internal_clamp_min() const {
  return clamp_min_;
}
inline int32_t LayerQuantizeParams_WeightParams::clamp_min() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_min)
  return _internal_clamp_min();
}
inline void LayerQuantizeParams_WeightParams::_internal_set_clamp_min(int32_t value) {
  _has_bits_[0] |= 0x00000020u;
  clamp_min_ = value;
}
inline void LayerQuantizeParams_WeightParams::set_clamp_min(int32_t value) {
  _internal_set_clamp_min(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_min)
}

// optional int32 clamp_max = 5 [default = 127];
inline bool LayerQuantizeParams_WeightParams::_internal_has_clamp_max() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WeightParams::has_clamp_max() const {
  return _internal_has_clamp_max();
}
inline void LayerQuantizeParams_WeightParams::clear_clamp_max() {
  clamp_max_ = 127;
  _has_bits_[0] &= ~0x00000008u;
}
inline int32_t LayerQuantizeParams_WeightParams::_internal_clamp_max() const {
  return clamp_max_;
}
inline int32_t LayerQuantizeParams_WeightParams::clamp_max() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_max)
  return _internal_clamp_max();
}
inline void LayerQuantizeParams_WeightParams::_internal_set_clamp_max(int32_t value) {
  _has_bits_[0] |= 0x00000008u;
  clamp_max_ = value;
}
inline void LayerQuantizeParams_WeightParams::set_clamp_max(int32_t value) {
  _internal_set_clamp_max(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.clamp_max)
}

// optional bool asymmetric = 6 [default = false];
inline bool LayerQuantizeParams_WeightParams::_internal_has_asymmetric() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WeightParams::has_asymmetric() const {
  return _internal_has_asymmetric();
}
inline void LayerQuantizeParams_WeightParams::clear_asymmetric() {
  asymmetric_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool LayerQuantizeParams_WeightParams::_internal_asymmetric() const {
  return asymmetric_;
}
inline bool LayerQuantizeParams_WeightParams::asymmetric() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.asymmetric)
  return _internal_asymmetric();
}
inline void LayerQuantizeParams_WeightParams::_internal_set_asymmetric(bool value) {
  _has_bits_[0] |= 0x00000002u;
  asymmetric_ = value;
}
inline void LayerQuantizeParams_WeightParams::set_asymmetric(bool value) {
  _internal_set_asymmetric(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.asymmetric)
}

// optional int32 block_size = 7 [default = 0];
inline bool LayerQuantizeParams_WeightParams::_internal_has_block_size() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WeightParams::has_block_size() const {
  return _internal_has_block_size();
}
inline void LayerQuantizeParams_WeightParams::clear_block_size() {
  block_size_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline int32_t LayerQuantizeParams_WeightParams::_internal_block_size() const {
  return block_size_;
}
inline int32_t LayerQuantizeParams_WeightParams::block_size() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WeightParams.block_size)
  return _internal_block_size();
}
inline void LayerQuantizeParams_WeightParams::_internal_set_block_size(int32_t value) {
  _has_bits_[0] |= 0x00000004u;
  block_size_ = value;
}
inline void LayerQuantizeParams_WeightParams::set_block_size(int32_t value) {
  _internal_set_block_size(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WeightParams.block_size)
}

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

// LayerQuantizeParams_WinogradParams

// required int32 version = 1 [default = 0];
inline bool LayerQuantizeParams_WinogradParams::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LayerQuantizeParams_WinogradParams::has_version() const {
  return _internal_has_version();
}
inline void LayerQuantizeParams_WinogradParams::clear_version() {
  version_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline int32_t LayerQuantizeParams_WinogradParams::_internal_version() const {
  return version_;
}
inline int32_t LayerQuantizeParams_WinogradParams::version() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WinogradParams.version)
  return _internal_version();
}
inline void LayerQuantizeParams_WinogradParams::_internal_set_version(int32_t value) {
  _has_bits_[0] |= 0x00000001u;
  version_ = value;
}
inline void LayerQuantizeParams_WinogradParams::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WinogradParams.version)
}

// repeated int32 units_attr = 4;
inline int LayerQuantizeParams_WinogradParams::_internal_units_attr_size() const {
  return units_attr_.size();
}
inline int LayerQuantizeParams_WinogradParams::units_attr_size() const {
  return _internal_units_attr_size();
}
inline void LayerQuantizeParams_WinogradParams::clear_units_attr() {
  units_attr_.Clear();
}
inline int32_t LayerQuantizeParams_WinogradParams::_internal_units_attr(int index) const {
  return units_attr_.Get(index);
}
inline int32_t LayerQuantizeParams_WinogradParams::units_attr(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
  return _internal_units_attr(index);
}
inline void LayerQuantizeParams_WinogradParams::set_units_attr(int index, int32_t value) {
  units_attr_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
}
inline void LayerQuantizeParams_WinogradParams::_internal_add_units_attr(int32_t value) {
  units_attr_.Add(value);
}
inline void LayerQuantizeParams_WinogradParams::add_units_attr(int32_t value) {
  _internal_add_units_attr(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
LayerQuantizeParams_WinogradParams::_internal_units_attr() const {
  return units_attr_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
LayerQuantizeParams_WinogradParams::units_attr() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
  return _internal_units_attr();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
LayerQuantizeParams_WinogradParams::_internal_mutable_units_attr() {
  return &units_attr_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
LayerQuantizeParams_WinogradParams::mutable_units_attr() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.WinogradParams.units_attr)
  return _internal_mutable_units_attr();
}

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

// LayerQuantizeParams_ConvolutionInfo

// required int32 input_channel = 1;
inline bool LayerQuantizeParams_ConvolutionInfo::_internal_has_input_channel() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ConvolutionInfo::has_input_channel() const {
  return _internal_has_input_channel();
}
inline void LayerQuantizeParams_ConvolutionInfo::clear_input_channel() {
  input_channel_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline int32_t LayerQuantizeParams_ConvolutionInfo::_internal_input_channel() const {
  return input_channel_;
}
inline int32_t LayerQuantizeParams_ConvolutionInfo::input_channel() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.input_channel)
  return _internal_input_channel();
}
inline void LayerQuantizeParams_ConvolutionInfo::_internal_set_input_channel(int32_t value) {
  _has_bits_[0] |= 0x00000001u;
  input_channel_ = value;
}
inline void LayerQuantizeParams_ConvolutionInfo::set_input_channel(int32_t value) {
  _internal_set_input_channel(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.input_channel)
}

// required int32 output_channel = 2;
inline bool LayerQuantizeParams_ConvolutionInfo::_internal_has_output_channel() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LayerQuantizeParams_ConvolutionInfo::has_output_channel() const {
  return _internal_has_output_channel();
}
inline void LayerQuantizeParams_ConvolutionInfo::clear_output_channel() {
  output_channel_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline int32_t LayerQuantizeParams_ConvolutionInfo::_internal_output_channel() const {
  return output_channel_;
}
inline int32_t LayerQuantizeParams_ConvolutionInfo::output_channel() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.output_channel)
  return _internal_output_channel();
}
inline void LayerQuantizeParams_ConvolutionInfo::_internal_set_output_channel(int32_t value) {
  _has_bits_[0] |= 0x00000002u;
  output_channel_ = value;
}
inline void LayerQuantizeParams_ConvolutionInfo::set_output_channel(int32_t value) {
  _internal_set_output_channel(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.output_channel)
}

// repeated int32 kernel_size = 3;
inline int LayerQuantizeParams_ConvolutionInfo::_internal_kernel_size_size() const {
  return kernel_size_.size();
}
inline int LayerQuantizeParams_ConvolutionInfo::kernel_size_size() const {
  return _internal_kernel_size_size();
}
inline void LayerQuantizeParams_ConvolutionInfo::clear_kernel_size() {
  kernel_size_.Clear();
}
inline int32_t LayerQuantizeParams_ConvolutionInfo::_internal_kernel_size(int index) const {
  return kernel_size_.Get(index);
}
inline int32_t LayerQuantizeParams_ConvolutionInfo::kernel_size(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
  return _internal_kernel_size(index);
}
inline void LayerQuantizeParams_ConvolutionInfo::set_kernel_size(int index, int32_t value) {
  kernel_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
}
inline void LayerQuantizeParams_ConvolutionInfo::_internal_add_kernel_size(int32_t value) {
  kernel_size_.Add(value);
}
inline void LayerQuantizeParams_ConvolutionInfo::add_kernel_size(int32_t value) {
  _internal_add_kernel_size(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
LayerQuantizeParams_ConvolutionInfo::_internal_kernel_size() const {
  return kernel_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
LayerQuantizeParams_ConvolutionInfo::kernel_size() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
  return _internal_kernel_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
LayerQuantizeParams_ConvolutionInfo::_internal_mutable_kernel_size() {
  return &kernel_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
LayerQuantizeParams_ConvolutionInfo::mutable_kernel_size() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.ConvolutionInfo.kernel_size)
  return _internal_mutable_kernel_size();
}

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

// LayerQuantizeParams

// repeated .MNN.Compression.LayerQuantizeParams.ActivationParams input = 1;
inline int LayerQuantizeParams::_internal_input_size() const {
  return input_.size();
}
inline int LayerQuantizeParams::input_size() const {
  return _internal_input_size();
}
inline void LayerQuantizeParams::clear_input() {
  input_.Clear();
}
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::mutable_input(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.input)
  return input_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
LayerQuantizeParams::mutable_input() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.input)
  return &input_;
}
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::_internal_input(int index) const {
  return input_.Get(index);
}
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::input(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.input)
  return _internal_input(index);
}
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::_internal_add_input() {
  return input_.Add();
}
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::add_input() {
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* _add = _internal_add_input();
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.input)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
LayerQuantizeParams::input() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.input)
  return input_;
}

// repeated .MNN.Compression.LayerQuantizeParams.WeightParams weight = 2;
inline int LayerQuantizeParams::_internal_weight_size() const {
  return weight_.size();
}
inline int LayerQuantizeParams::weight_size() const {
  return _internal_weight_size();
}
inline void LayerQuantizeParams::clear_weight() {
  weight_.Clear();
}
inline ::MNN::Compression::LayerQuantizeParams_WeightParams* LayerQuantizeParams::mutable_weight(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.weight)
  return weight_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >*
LayerQuantizeParams::mutable_weight() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.weight)
  return &weight_;
}
inline const ::MNN::Compression::LayerQuantizeParams_WeightParams& LayerQuantizeParams::_internal_weight(int index) const {
  return weight_.Get(index);
}
inline const ::MNN::Compression::LayerQuantizeParams_WeightParams& LayerQuantizeParams::weight(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.weight)
  return _internal_weight(index);
}
inline ::MNN::Compression::LayerQuantizeParams_WeightParams* LayerQuantizeParams::_internal_add_weight() {
  return weight_.Add();
}
inline ::MNN::Compression::LayerQuantizeParams_WeightParams* LayerQuantizeParams::add_weight() {
  ::MNN::Compression::LayerQuantizeParams_WeightParams* _add = _internal_add_weight();
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.weight)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_WeightParams >&
LayerQuantizeParams::weight() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.weight)
  return weight_;
}

// repeated .MNN.Compression.LayerQuantizeParams.ActivationParams output = 3;
inline int LayerQuantizeParams::_internal_output_size() const {
  return output_.size();
}
inline int LayerQuantizeParams::output_size() const {
  return _internal_output_size();
}
inline void LayerQuantizeParams::clear_output() {
  output_.Clear();
}
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::mutable_output(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.output)
  return output_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >*
LayerQuantizeParams::mutable_output() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LayerQuantizeParams.output)
  return &output_;
}
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::_internal_output(int index) const {
  return output_.Get(index);
}
inline const ::MNN::Compression::LayerQuantizeParams_ActivationParams& LayerQuantizeParams::output(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.output)
  return _internal_output(index);
}
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::_internal_add_output() {
  return output_.Add();
}
inline ::MNN::Compression::LayerQuantizeParams_ActivationParams* LayerQuantizeParams::add_output() {
  ::MNN::Compression::LayerQuantizeParams_ActivationParams* _add = _internal_add_output();
  // @@protoc_insertion_point(field_add:MNN.Compression.LayerQuantizeParams.output)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::LayerQuantizeParams_ActivationParams >&
LayerQuantizeParams::output() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LayerQuantizeParams.output)
  return output_;
}

// optional .MNN.Compression.LayerQuantizeParams.QuantMethod method = 4 [default = QAT];
inline bool LayerQuantizeParams::_internal_has_method() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LayerQuantizeParams::has_method() const {
  return _internal_has_method();
}
inline void LayerQuantizeParams::clear_method() {
  method_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::MNN::Compression::LayerQuantizeParams_QuantMethod LayerQuantizeParams::_internal_method() const {
  return static_cast< ::MNN::Compression::LayerQuantizeParams_QuantMethod >(method_);
}
inline ::MNN::Compression::LayerQuantizeParams_QuantMethod LayerQuantizeParams::method() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.method)
  return _internal_method();
}
inline void LayerQuantizeParams::_internal_set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value) {
  assert(::MNN::Compression::LayerQuantizeParams_QuantMethod_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  method_ = value;
}
inline void LayerQuantizeParams::set_method(::MNN::Compression::LayerQuantizeParams_QuantMethod value) {
  _internal_set_method(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.method)
}

// optional .MNN.Compression.LayerQuantizeParams.WinogradParams wino_params = 5;
inline bool LayerQuantizeParams::_internal_has_wino_params() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || wino_params_ != nullptr);
  return value;
}
inline bool LayerQuantizeParams::has_wino_params() const {
  return _internal_has_wino_params();
}
inline void LayerQuantizeParams::clear_wino_params() {
  if (wino_params_ != nullptr) wino_params_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::MNN::Compression::LayerQuantizeParams_WinogradParams& LayerQuantizeParams::_internal_wino_params() const {
  const ::MNN::Compression::LayerQuantizeParams_WinogradParams* p = wino_params_;
  return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::LayerQuantizeParams_WinogradParams&>(
      ::MNN::Compression::_LayerQuantizeParams_WinogradParams_default_instance_);
}
inline const ::MNN::Compression::LayerQuantizeParams_WinogradParams& LayerQuantizeParams::wino_params() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.wino_params)
  return _internal_wino_params();
}
inline void LayerQuantizeParams::unsafe_arena_set_allocated_wino_params(
    ::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wino_params_);
  }
  wino_params_ = wino_params;
  if (wino_params) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.LayerQuantizeParams.wino_params)
}
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::release_wino_params() {
  _has_bits_[0] &= ~0x00000004u;
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* temp = wino_params_;
  wino_params_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::unsafe_arena_release_wino_params() {
  // @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.wino_params)
  _has_bits_[0] &= ~0x00000004u;
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* temp = wino_params_;
  wino_params_ = nullptr;
  return temp;
}
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::_internal_mutable_wino_params() {
  _has_bits_[0] |= 0x00000004u;
  if (wino_params_ == nullptr) {
    auto* p = CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_WinogradParams>(GetArenaForAllocation());
    wino_params_ = p;
  }
  return wino_params_;
}
inline ::MNN::Compression::LayerQuantizeParams_WinogradParams* LayerQuantizeParams::mutable_wino_params() {
  ::MNN::Compression::LayerQuantizeParams_WinogradParams* _msg = _internal_mutable_wino_params();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.wino_params)
  return _msg;
}
inline void LayerQuantizeParams::set_allocated_wino_params(::MNN::Compression::LayerQuantizeParams_WinogradParams* wino_params) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete wino_params_;
  }
  if (wino_params) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::LayerQuantizeParams_WinogradParams>::GetOwningArena(wino_params);
    if (message_arena != submessage_arena) {
      wino_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wino_params, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  wino_params_ = wino_params;
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.wino_params)
}

// optional string op_name = 6;
inline bool LayerQuantizeParams::_internal_has_op_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LayerQuantizeParams::has_op_name() const {
  return _internal_has_op_name();
}
inline void LayerQuantizeParams::clear_op_name() {
  op_name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LayerQuantizeParams::op_name() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.op_name)
  return _internal_op_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerQuantizeParams::set_op_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 op_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.op_name)
}
inline std::string* LayerQuantizeParams::mutable_op_name() {
  std::string* _s = _internal_mutable_op_name();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.op_name)
  return _s;
}
inline const std::string& LayerQuantizeParams::_internal_op_name() const {
  return op_name_.Get();
}
inline void LayerQuantizeParams::_internal_set_op_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  op_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams::_internal_mutable_op_name() {
  _has_bits_[0] |= 0x00000001u;
  return op_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams::release_op_name() {
  // @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.op_name)
  if (!_internal_has_op_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = op_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (op_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LayerQuantizeParams::set_allocated_op_name(std::string* op_name) {
  if (op_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  op_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (op_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.op_name)
}

// optional string subgraph_name = 7;
inline bool LayerQuantizeParams::_internal_has_subgraph_name() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LayerQuantizeParams::has_subgraph_name() const {
  return _internal_has_subgraph_name();
}
inline void LayerQuantizeParams::clear_subgraph_name() {
  subgraph_name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LayerQuantizeParams::subgraph_name() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.subgraph_name)
  return _internal_subgraph_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerQuantizeParams::set_subgraph_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 subgraph_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:MNN.Compression.LayerQuantizeParams.subgraph_name)
}
inline std::string* LayerQuantizeParams::mutable_subgraph_name() {
  std::string* _s = _internal_mutable_subgraph_name();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.subgraph_name)
  return _s;
}
inline const std::string& LayerQuantizeParams::_internal_subgraph_name() const {
  return subgraph_name_.Get();
}
inline void LayerQuantizeParams::_internal_set_subgraph_name(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  subgraph_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams::_internal_mutable_subgraph_name() {
  _has_bits_[0] |= 0x00000002u;
  return subgraph_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LayerQuantizeParams::release_subgraph_name() {
  // @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.subgraph_name)
  if (!_internal_has_subgraph_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = subgraph_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (subgraph_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    subgraph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LayerQuantizeParams::set_allocated_subgraph_name(std::string* subgraph_name) {
  if (subgraph_name != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  subgraph_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), subgraph_name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (subgraph_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    subgraph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.subgraph_name)
}

// optional .MNN.Compression.LayerQuantizeParams.ConvolutionInfo conv = 8;
inline bool LayerQuantizeParams::_internal_has_conv() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || conv_ != nullptr);
  return value;
}
inline bool LayerQuantizeParams::has_conv() const {
  return _internal_has_conv();
}
inline void LayerQuantizeParams::clear_conv() {
  if (conv_ != nullptr) conv_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& LayerQuantizeParams::_internal_conv() const {
  const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* p = conv_;
  return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo&>(
      ::MNN::Compression::_LayerQuantizeParams_ConvolutionInfo_default_instance_);
}
inline const ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo& LayerQuantizeParams::conv() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LayerQuantizeParams.conv)
  return _internal_conv();
}
inline void LayerQuantizeParams::unsafe_arena_set_allocated_conv(
    ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(conv_);
  }
  conv_ = conv;
  if (conv) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.LayerQuantizeParams.conv)
}
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::release_conv() {
  _has_bits_[0] &= ~0x00000008u;
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* temp = conv_;
  conv_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::unsafe_arena_release_conv() {
  // @@protoc_insertion_point(field_release:MNN.Compression.LayerQuantizeParams.conv)
  _has_bits_[0] &= ~0x00000008u;
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* temp = conv_;
  conv_ = nullptr;
  return temp;
}
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::_internal_mutable_conv() {
  _has_bits_[0] |= 0x00000008u;
  if (conv_ == nullptr) {
    auto* p = CreateMaybeMessage<::MNN::Compression::LayerQuantizeParams_ConvolutionInfo>(GetArenaForAllocation());
    conv_ = p;
  }
  return conv_;
}
inline ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* LayerQuantizeParams::mutable_conv() {
  ::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* _msg = _internal_mutable_conv();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LayerQuantizeParams.conv)
  return _msg;
}
inline void LayerQuantizeParams::set_allocated_conv(::MNN::Compression::LayerQuantizeParams_ConvolutionInfo* conv) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete conv_;
  }
  if (conv) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::LayerQuantizeParams_ConvolutionInfo>::GetOwningArena(conv);
    if (message_arena != submessage_arena) {
      conv = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, conv, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  conv_ = conv;
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.LayerQuantizeParams.conv)
}

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

// LevelPrunerParams

// repeated string weight_tensor_names = 1;
inline int LevelPrunerParams::_internal_weight_tensor_names_size() const {
  return weight_tensor_names_.size();
}
inline int LevelPrunerParams::weight_tensor_names_size() const {
  return _internal_weight_tensor_names_size();
}
inline void LevelPrunerParams::clear_weight_tensor_names() {
  weight_tensor_names_.Clear();
}
inline std::string* LevelPrunerParams::add_weight_tensor_names() {
  std::string* _s = _internal_add_weight_tensor_names();
  // @@protoc_insertion_point(field_add_mutable:MNN.Compression.LevelPrunerParams.weight_tensor_names)
  return _s;
}
inline const std::string& LevelPrunerParams::_internal_weight_tensor_names(int index) const {
  return weight_tensor_names_.Get(index);
}
inline const std::string& LevelPrunerParams::weight_tensor_names(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LevelPrunerParams.weight_tensor_names)
  return _internal_weight_tensor_names(index);
}
inline std::string* LevelPrunerParams::mutable_weight_tensor_names(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LevelPrunerParams.weight_tensor_names)
  return weight_tensor_names_.Mutable(index);
}
inline void LevelPrunerParams::set_weight_tensor_names(int index, const std::string& value) {
  weight_tensor_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline void LevelPrunerParams::set_weight_tensor_names(int index, std::string&& value) {
  weight_tensor_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline void LevelPrunerParams::set_weight_tensor_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  weight_tensor_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline void LevelPrunerParams::set_weight_tensor_names(int index, const char* value, size_t size) {
  weight_tensor_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline std::string* LevelPrunerParams::_internal_add_weight_tensor_names() {
  return weight_tensor_names_.Add();
}
inline void LevelPrunerParams::add_weight_tensor_names(const std::string& value) {
  weight_tensor_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline void LevelPrunerParams::add_weight_tensor_names(std::string&& value) {
  weight_tensor_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline void LevelPrunerParams::add_weight_tensor_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  weight_tensor_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline void LevelPrunerParams::add_weight_tensor_names(const char* value, size_t size) {
  weight_tensor_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:MNN.Compression.LevelPrunerParams.weight_tensor_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LevelPrunerParams::weight_tensor_names() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LevelPrunerParams.weight_tensor_names)
  return weight_tensor_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LevelPrunerParams::mutable_weight_tensor_names() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LevelPrunerParams.weight_tensor_names)
  return &weight_tensor_names_;
}

// repeated float prune_ratios = 2;
inline int LevelPrunerParams::_internal_prune_ratios_size() const {
  return prune_ratios_.size();
}
inline int LevelPrunerParams::prune_ratios_size() const {
  return _internal_prune_ratios_size();
}
inline void LevelPrunerParams::clear_prune_ratios() {
  prune_ratios_.Clear();
}
inline float LevelPrunerParams::_internal_prune_ratios(int index) const {
  return prune_ratios_.Get(index);
}
inline float LevelPrunerParams::prune_ratios(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LevelPrunerParams.prune_ratios)
  return _internal_prune_ratios(index);
}
inline void LevelPrunerParams::set_prune_ratios(int index, float value) {
  prune_ratios_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.prune_ratios)
}
inline void LevelPrunerParams::_internal_add_prune_ratios(float value) {
  prune_ratios_.Add(value);
}
inline void LevelPrunerParams::add_prune_ratios(float value) {
  _internal_add_prune_ratios(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.prune_ratios)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LevelPrunerParams::_internal_prune_ratios() const {
  return prune_ratios_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LevelPrunerParams::prune_ratios() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LevelPrunerParams.prune_ratios)
  return _internal_prune_ratios();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LevelPrunerParams::_internal_mutable_prune_ratios() {
  return &prune_ratios_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LevelPrunerParams::mutable_prune_ratios() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LevelPrunerParams.prune_ratios)
  return _internal_mutable_prune_ratios();
}

// repeated string layer_names = 3;
inline int LevelPrunerParams::_internal_layer_names_size() const {
  return layer_names_.size();
}
inline int LevelPrunerParams::layer_names_size() const {
  return _internal_layer_names_size();
}
inline void LevelPrunerParams::clear_layer_names() {
  layer_names_.Clear();
}
inline std::string* LevelPrunerParams::add_layer_names() {
  std::string* _s = _internal_add_layer_names();
  // @@protoc_insertion_point(field_add_mutable:MNN.Compression.LevelPrunerParams.layer_names)
  return _s;
}
inline const std::string& LevelPrunerParams::_internal_layer_names(int index) const {
  return layer_names_.Get(index);
}
inline const std::string& LevelPrunerParams::layer_names(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.LevelPrunerParams.layer_names)
  return _internal_layer_names(index);
}
inline std::string* LevelPrunerParams::mutable_layer_names(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.LevelPrunerParams.layer_names)
  return layer_names_.Mutable(index);
}
inline void LevelPrunerParams::set_layer_names(int index, const std::string& value) {
  layer_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.layer_names)
}
inline void LevelPrunerParams::set_layer_names(int index, std::string&& value) {
  layer_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:MNN.Compression.LevelPrunerParams.layer_names)
}
inline void LevelPrunerParams::set_layer_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  layer_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:MNN.Compression.LevelPrunerParams.layer_names)
}
inline void LevelPrunerParams::set_layer_names(int index, const char* value, size_t size) {
  layer_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:MNN.Compression.LevelPrunerParams.layer_names)
}
inline std::string* LevelPrunerParams::_internal_add_layer_names() {
  return layer_names_.Add();
}
inline void LevelPrunerParams::add_layer_names(const std::string& value) {
  layer_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.layer_names)
}
inline void LevelPrunerParams::add_layer_names(std::string&& value) {
  layer_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:MNN.Compression.LevelPrunerParams.layer_names)
}
inline void LevelPrunerParams::add_layer_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  layer_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:MNN.Compression.LevelPrunerParams.layer_names)
}
inline void LevelPrunerParams::add_layer_names(const char* value, size_t size) {
  layer_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:MNN.Compression.LevelPrunerParams.layer_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LevelPrunerParams::layer_names() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.LevelPrunerParams.layer_names)
  return layer_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LevelPrunerParams::mutable_layer_names() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.LevelPrunerParams.layer_names)
  return &layer_names_;
}

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

// SIMDOCPrunerParams

// repeated string weight_tensor_names = 1;
inline int SIMDOCPrunerParams::_internal_weight_tensor_names_size() const {
  return weight_tensor_names_.size();
}
inline int SIMDOCPrunerParams::weight_tensor_names_size() const {
  return _internal_weight_tensor_names_size();
}
inline void SIMDOCPrunerParams::clear_weight_tensor_names() {
  weight_tensor_names_.Clear();
}
inline std::string* SIMDOCPrunerParams::add_weight_tensor_names() {
  std::string* _s = _internal_add_weight_tensor_names();
  // @@protoc_insertion_point(field_add_mutable:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
  return _s;
}
inline const std::string& SIMDOCPrunerParams::_internal_weight_tensor_names(int index) const {
  return weight_tensor_names_.Get(index);
}
inline const std::string& SIMDOCPrunerParams::weight_tensor_names(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
  return _internal_weight_tensor_names(index);
}
inline std::string* SIMDOCPrunerParams::mutable_weight_tensor_names(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
  return weight_tensor_names_.Mutable(index);
}
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, const std::string& value) {
  weight_tensor_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, std::string&& value) {
  weight_tensor_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  weight_tensor_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline void SIMDOCPrunerParams::set_weight_tensor_names(int index, const char* value, size_t size) {
  weight_tensor_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline std::string* SIMDOCPrunerParams::_internal_add_weight_tensor_names() {
  return weight_tensor_names_.Add();
}
inline void SIMDOCPrunerParams::add_weight_tensor_names(const std::string& value) {
  weight_tensor_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline void SIMDOCPrunerParams::add_weight_tensor_names(std::string&& value) {
  weight_tensor_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline void SIMDOCPrunerParams::add_weight_tensor_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  weight_tensor_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline void SIMDOCPrunerParams::add_weight_tensor_names(const char* value, size_t size) {
  weight_tensor_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SIMDOCPrunerParams::weight_tensor_names() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
  return weight_tensor_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SIMDOCPrunerParams::mutable_weight_tensor_names() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.weight_tensor_names)
  return &weight_tensor_names_;
}

// repeated float prune_ratios = 2;
inline int SIMDOCPrunerParams::_internal_prune_ratios_size() const {
  return prune_ratios_.size();
}
inline int SIMDOCPrunerParams::prune_ratios_size() const {
  return _internal_prune_ratios_size();
}
inline void SIMDOCPrunerParams::clear_prune_ratios() {
  prune_ratios_.Clear();
}
inline float SIMDOCPrunerParams::_internal_prune_ratios(int index) const {
  return prune_ratios_.Get(index);
}
inline float SIMDOCPrunerParams::prune_ratios(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
  return _internal_prune_ratios(index);
}
inline void SIMDOCPrunerParams::set_prune_ratios(int index, float value) {
  prune_ratios_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
}
inline void SIMDOCPrunerParams::_internal_add_prune_ratios(float value) {
  prune_ratios_.Add(value);
}
inline void SIMDOCPrunerParams::add_prune_ratios(float value) {
  _internal_add_prune_ratios(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SIMDOCPrunerParams::_internal_prune_ratios() const {
  return prune_ratios_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
SIMDOCPrunerParams::prune_ratios() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
  return _internal_prune_ratios();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SIMDOCPrunerParams::_internal_mutable_prune_ratios() {
  return &prune_ratios_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
SIMDOCPrunerParams::mutable_prune_ratios() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.prune_ratios)
  return _internal_mutable_prune_ratios();
}

// repeated string layer_names = 3;
inline int SIMDOCPrunerParams::_internal_layer_names_size() const {
  return layer_names_.size();
}
inline int SIMDOCPrunerParams::layer_names_size() const {
  return _internal_layer_names_size();
}
inline void SIMDOCPrunerParams::clear_layer_names() {
  layer_names_.Clear();
}
inline std::string* SIMDOCPrunerParams::add_layer_names() {
  std::string* _s = _internal_add_layer_names();
  // @@protoc_insertion_point(field_add_mutable:MNN.Compression.SIMDOCPrunerParams.layer_names)
  return _s;
}
inline const std::string& SIMDOCPrunerParams::_internal_layer_names(int index) const {
  return layer_names_.Get(index);
}
inline const std::string& SIMDOCPrunerParams::layer_names(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.layer_names)
  return _internal_layer_names(index);
}
inline std::string* SIMDOCPrunerParams::mutable_layer_names(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.SIMDOCPrunerParams.layer_names)
  return layer_names_.Mutable(index);
}
inline void SIMDOCPrunerParams::set_layer_names(int index, const std::string& value) {
  layer_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline void SIMDOCPrunerParams::set_layer_names(int index, std::string&& value) {
  layer_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline void SIMDOCPrunerParams::set_layer_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  layer_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline void SIMDOCPrunerParams::set_layer_names(int index, const char* value, size_t size) {
  layer_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline std::string* SIMDOCPrunerParams::_internal_add_layer_names() {
  return layer_names_.Add();
}
inline void SIMDOCPrunerParams::add_layer_names(const std::string& value) {
  layer_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline void SIMDOCPrunerParams::add_layer_names(std::string&& value) {
  layer_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline void SIMDOCPrunerParams::add_layer_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  layer_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline void SIMDOCPrunerParams::add_layer_names(const char* value, size_t size) {
  layer_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:MNN.Compression.SIMDOCPrunerParams.layer_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SIMDOCPrunerParams::layer_names() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.layer_names)
  return layer_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SIMDOCPrunerParams::mutable_layer_names() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.layer_names)
  return &layer_names_;
}

// repeated int32 oc_blocks = 4;
inline int SIMDOCPrunerParams::_internal_oc_blocks_size() const {
  return oc_blocks_.size();
}
inline int SIMDOCPrunerParams::oc_blocks_size() const {
  return _internal_oc_blocks_size();
}
inline void SIMDOCPrunerParams::clear_oc_blocks() {
  oc_blocks_.Clear();
}
inline int32_t SIMDOCPrunerParams::_internal_oc_blocks(int index) const {
  return oc_blocks_.Get(index);
}
inline int32_t SIMDOCPrunerParams::oc_blocks(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
  return _internal_oc_blocks(index);
}
inline void SIMDOCPrunerParams::set_oc_blocks(int index, int32_t value) {
  oc_blocks_.Set(index, value);
  // @@protoc_insertion_point(field_set:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
}
inline void SIMDOCPrunerParams::_internal_add_oc_blocks(int32_t value) {
  oc_blocks_.Add(value);
}
inline void SIMDOCPrunerParams::add_oc_blocks(int32_t value) {
  _internal_add_oc_blocks(value);
  // @@protoc_insertion_point(field_add:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SIMDOCPrunerParams::_internal_oc_blocks() const {
  return oc_blocks_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SIMDOCPrunerParams::oc_blocks() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
  return _internal_oc_blocks();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SIMDOCPrunerParams::_internal_mutable_oc_blocks() {
  return &oc_blocks_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SIMDOCPrunerParams::mutable_oc_blocks() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.SIMDOCPrunerParams.oc_blocks)
  return _internal_mutable_oc_blocks();
}

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

// PruneParams

// optional .MNN.Compression.PruneParams.PruneType type = 1 [default = RANDOM];
inline bool PruneParams::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PruneParams::has_type() const {
  return _internal_has_type();
}
inline void PruneParams::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::MNN::Compression::PruneParams_PruneType PruneParams::_internal_type() const {
  return static_cast< ::MNN::Compression::PruneParams_PruneType >(type_);
}
inline ::MNN::Compression::PruneParams_PruneType PruneParams::type() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.PruneParams.type)
  return _internal_type();
}
inline void PruneParams::_internal_set_type(::MNN::Compression::PruneParams_PruneType value) {
  assert(::MNN::Compression::PruneParams_PruneType_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  type_ = value;
}
inline void PruneParams::set_type(::MNN::Compression::PruneParams_PruneType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.PruneParams.type)
}

// optional .MNN.Compression.LevelPrunerParams level_pruner_params = 2;
inline bool PruneParams::_internal_has_level_pruner_params() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || level_pruner_params_ != nullptr);
  return value;
}
inline bool PruneParams::has_level_pruner_params() const {
  return _internal_has_level_pruner_params();
}
inline void PruneParams::clear_level_pruner_params() {
  if (level_pruner_params_ != nullptr) level_pruner_params_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::MNN::Compression::LevelPrunerParams& PruneParams::_internal_level_pruner_params() const {
  const ::MNN::Compression::LevelPrunerParams* p = level_pruner_params_;
  return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::LevelPrunerParams&>(
      ::MNN::Compression::_LevelPrunerParams_default_instance_);
}
inline const ::MNN::Compression::LevelPrunerParams& PruneParams::level_pruner_params() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.PruneParams.level_pruner_params)
  return _internal_level_pruner_params();
}
inline void PruneParams::unsafe_arena_set_allocated_level_pruner_params(
    ::MNN::Compression::LevelPrunerParams* level_pruner_params) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(level_pruner_params_);
  }
  level_pruner_params_ = level_pruner_params;
  if (level_pruner_params) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.PruneParams.level_pruner_params)
}
inline ::MNN::Compression::LevelPrunerParams* PruneParams::release_level_pruner_params() {
  _has_bits_[0] &= ~0x00000001u;
  ::MNN::Compression::LevelPrunerParams* temp = level_pruner_params_;
  level_pruner_params_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::MNN::Compression::LevelPrunerParams* PruneParams::unsafe_arena_release_level_pruner_params() {
  // @@protoc_insertion_point(field_release:MNN.Compression.PruneParams.level_pruner_params)
  _has_bits_[0] &= ~0x00000001u;
  ::MNN::Compression::LevelPrunerParams* temp = level_pruner_params_;
  level_pruner_params_ = nullptr;
  return temp;
}
inline ::MNN::Compression::LevelPrunerParams* PruneParams::_internal_mutable_level_pruner_params() {
  _has_bits_[0] |= 0x00000001u;
  if (level_pruner_params_ == nullptr) {
    auto* p = CreateMaybeMessage<::MNN::Compression::LevelPrunerParams>(GetArenaForAllocation());
    level_pruner_params_ = p;
  }
  return level_pruner_params_;
}
inline ::MNN::Compression::LevelPrunerParams* PruneParams::mutable_level_pruner_params() {
  ::MNN::Compression::LevelPrunerParams* _msg = _internal_mutable_level_pruner_params();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.PruneParams.level_pruner_params)
  return _msg;
}
inline void PruneParams::set_allocated_level_pruner_params(::MNN::Compression::LevelPrunerParams* level_pruner_params) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete level_pruner_params_;
  }
  if (level_pruner_params) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::LevelPrunerParams>::GetOwningArena(level_pruner_params);
    if (message_arena != submessage_arena) {
      level_pruner_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, level_pruner_params, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  level_pruner_params_ = level_pruner_params;
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.PruneParams.level_pruner_params)
}

// optional .MNN.Compression.SIMDOCPrunerParams simd_oc_pruner_params = 3;
inline bool PruneParams::_internal_has_simd_oc_pruner_params() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || simd_oc_pruner_params_ != nullptr);
  return value;
}
inline bool PruneParams::has_simd_oc_pruner_params() const {
  return _internal_has_simd_oc_pruner_params();
}
inline void PruneParams::clear_simd_oc_pruner_params() {
  if (simd_oc_pruner_params_ != nullptr) simd_oc_pruner_params_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::MNN::Compression::SIMDOCPrunerParams& PruneParams::_internal_simd_oc_pruner_params() const {
  const ::MNN::Compression::SIMDOCPrunerParams* p = simd_oc_pruner_params_;
  return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::SIMDOCPrunerParams&>(
      ::MNN::Compression::_SIMDOCPrunerParams_default_instance_);
}
inline const ::MNN::Compression::SIMDOCPrunerParams& PruneParams::simd_oc_pruner_params() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.PruneParams.simd_oc_pruner_params)
  return _internal_simd_oc_pruner_params();
}
inline void PruneParams::unsafe_arena_set_allocated_simd_oc_pruner_params(
    ::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(simd_oc_pruner_params_);
  }
  simd_oc_pruner_params_ = simd_oc_pruner_params;
  if (simd_oc_pruner_params) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.PruneParams.simd_oc_pruner_params)
}
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::release_simd_oc_pruner_params() {
  _has_bits_[0] &= ~0x00000002u;
  ::MNN::Compression::SIMDOCPrunerParams* temp = simd_oc_pruner_params_;
  simd_oc_pruner_params_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::unsafe_arena_release_simd_oc_pruner_params() {
  // @@protoc_insertion_point(field_release:MNN.Compression.PruneParams.simd_oc_pruner_params)
  _has_bits_[0] &= ~0x00000002u;
  ::MNN::Compression::SIMDOCPrunerParams* temp = simd_oc_pruner_params_;
  simd_oc_pruner_params_ = nullptr;
  return temp;
}
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::_internal_mutable_simd_oc_pruner_params() {
  _has_bits_[0] |= 0x00000002u;
  if (simd_oc_pruner_params_ == nullptr) {
    auto* p = CreateMaybeMessage<::MNN::Compression::SIMDOCPrunerParams>(GetArenaForAllocation());
    simd_oc_pruner_params_ = p;
  }
  return simd_oc_pruner_params_;
}
inline ::MNN::Compression::SIMDOCPrunerParams* PruneParams::mutable_simd_oc_pruner_params() {
  ::MNN::Compression::SIMDOCPrunerParams* _msg = _internal_mutable_simd_oc_pruner_params();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.PruneParams.simd_oc_pruner_params)
  return _msg;
}
inline void PruneParams::set_allocated_simd_oc_pruner_params(::MNN::Compression::SIMDOCPrunerParams* simd_oc_pruner_params) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete simd_oc_pruner_params_;
  }
  if (simd_oc_pruner_params) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::SIMDOCPrunerParams>::GetOwningArena(simd_oc_pruner_params);
    if (message_arena != submessage_arena) {
      simd_oc_pruner_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, simd_oc_pruner_params, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  simd_oc_pruner_params_ = simd_oc_pruner_params;
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.PruneParams.simd_oc_pruner_params)
}

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

// CompressionAlgo

// optional .MNN.Compression.CompressionAlgo.CompressionType type = 1 [default = QUANTIZE];
inline bool CompressionAlgo::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CompressionAlgo::has_type() const {
  return _internal_has_type();
}
inline void CompressionAlgo::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::MNN::Compression::CompressionAlgo_CompressionType CompressionAlgo::_internal_type() const {
  return static_cast< ::MNN::Compression::CompressionAlgo_CompressionType >(type_);
}
inline ::MNN::Compression::CompressionAlgo_CompressionType CompressionAlgo::type() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.CompressionAlgo.type)
  return _internal_type();
}
inline void CompressionAlgo::_internal_set_type(::MNN::Compression::CompressionAlgo_CompressionType value) {
  assert(::MNN::Compression::CompressionAlgo_CompressionType_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  type_ = value;
}
inline void CompressionAlgo::set_type(::MNN::Compression::CompressionAlgo_CompressionType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.CompressionAlgo.type)
}

// optional .MNN.Compression.QuantizeParams quant_params = 2;
inline bool CompressionAlgo::_internal_has_quant_params() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || quant_params_ != nullptr);
  return value;
}
inline bool CompressionAlgo::has_quant_params() const {
  return _internal_has_quant_params();
}
inline void CompressionAlgo::clear_quant_params() {
  if (quant_params_ != nullptr) quant_params_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::MNN::Compression::QuantizeParams& CompressionAlgo::_internal_quant_params() const {
  const ::MNN::Compression::QuantizeParams* p = quant_params_;
  return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::QuantizeParams&>(
      ::MNN::Compression::_QuantizeParams_default_instance_);
}
inline const ::MNN::Compression::QuantizeParams& CompressionAlgo::quant_params() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.CompressionAlgo.quant_params)
  return _internal_quant_params();
}
inline void CompressionAlgo::unsafe_arena_set_allocated_quant_params(
    ::MNN::Compression::QuantizeParams* quant_params) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quant_params_);
  }
  quant_params_ = quant_params;
  if (quant_params) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.CompressionAlgo.quant_params)
}
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::release_quant_params() {
  _has_bits_[0] &= ~0x00000001u;
  ::MNN::Compression::QuantizeParams* temp = quant_params_;
  quant_params_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::unsafe_arena_release_quant_params() {
  // @@protoc_insertion_point(field_release:MNN.Compression.CompressionAlgo.quant_params)
  _has_bits_[0] &= ~0x00000001u;
  ::MNN::Compression::QuantizeParams* temp = quant_params_;
  quant_params_ = nullptr;
  return temp;
}
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::_internal_mutable_quant_params() {
  _has_bits_[0] |= 0x00000001u;
  if (quant_params_ == nullptr) {
    auto* p = CreateMaybeMessage<::MNN::Compression::QuantizeParams>(GetArenaForAllocation());
    quant_params_ = p;
  }
  return quant_params_;
}
inline ::MNN::Compression::QuantizeParams* CompressionAlgo::mutable_quant_params() {
  ::MNN::Compression::QuantizeParams* _msg = _internal_mutable_quant_params();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.CompressionAlgo.quant_params)
  return _msg;
}
inline void CompressionAlgo::set_allocated_quant_params(::MNN::Compression::QuantizeParams* quant_params) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete quant_params_;
  }
  if (quant_params) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::QuantizeParams>::GetOwningArena(quant_params);
    if (message_arena != submessage_arena) {
      quant_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quant_params, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  quant_params_ = quant_params;
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.CompressionAlgo.quant_params)
}

// optional .MNN.Compression.PruneParams prune_params = 3;
inline bool CompressionAlgo::_internal_has_prune_params() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || prune_params_ != nullptr);
  return value;
}
inline bool CompressionAlgo::has_prune_params() const {
  return _internal_has_prune_params();
}
inline void CompressionAlgo::clear_prune_params() {
  if (prune_params_ != nullptr) prune_params_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::MNN::Compression::PruneParams& CompressionAlgo::_internal_prune_params() const {
  const ::MNN::Compression::PruneParams* p = prune_params_;
  return p != nullptr ? *p : reinterpret_cast<const ::MNN::Compression::PruneParams&>(
      ::MNN::Compression::_PruneParams_default_instance_);
}
inline const ::MNN::Compression::PruneParams& CompressionAlgo::prune_params() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.CompressionAlgo.prune_params)
  return _internal_prune_params();
}
inline void CompressionAlgo::unsafe_arena_set_allocated_prune_params(
    ::MNN::Compression::PruneParams* prune_params) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(prune_params_);
  }
  prune_params_ = prune_params;
  if (prune_params) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MNN.Compression.CompressionAlgo.prune_params)
}
inline ::MNN::Compression::PruneParams* CompressionAlgo::release_prune_params() {
  _has_bits_[0] &= ~0x00000002u;
  ::MNN::Compression::PruneParams* temp = prune_params_;
  prune_params_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::MNN::Compression::PruneParams* CompressionAlgo::unsafe_arena_release_prune_params() {
  // @@protoc_insertion_point(field_release:MNN.Compression.CompressionAlgo.prune_params)
  _has_bits_[0] &= ~0x00000002u;
  ::MNN::Compression::PruneParams* temp = prune_params_;
  prune_params_ = nullptr;
  return temp;
}
inline ::MNN::Compression::PruneParams* CompressionAlgo::_internal_mutable_prune_params() {
  _has_bits_[0] |= 0x00000002u;
  if (prune_params_ == nullptr) {
    auto* p = CreateMaybeMessage<::MNN::Compression::PruneParams>(GetArenaForAllocation());
    prune_params_ = p;
  }
  return prune_params_;
}
inline ::MNN::Compression::PruneParams* CompressionAlgo::mutable_prune_params() {
  ::MNN::Compression::PruneParams* _msg = _internal_mutable_prune_params();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.CompressionAlgo.prune_params)
  return _msg;
}
inline void CompressionAlgo::set_allocated_prune_params(::MNN::Compression::PruneParams* prune_params) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete prune_params_;
  }
  if (prune_params) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::MNN::Compression::PruneParams>::GetOwningArena(prune_params);
    if (message_arena != submessage_arena) {
      prune_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, prune_params, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  prune_params_ = prune_params;
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.CompressionAlgo.prune_params)
}

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

// Pipeline

// required string version = 1 [default = "0.0.0"];
inline bool Pipeline::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Pipeline::has_version() const {
  return _internal_has_version();
}
inline void Pipeline::clear_version() {
  version_.ClearToDefault(::MNN::Compression::Pipeline::_i_give_permission_to_break_this_code_default_version_, GetArenaForAllocation());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Pipeline::version() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.version)
  if (version_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_version_.get();
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Pipeline::set_version(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:MNN.Compression.Pipeline.version)
}
inline std::string* Pipeline::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.Pipeline.version)
  return _s;
}
inline const std::string& Pipeline::_internal_version() const {
  return version_.Get();
}
inline void Pipeline::_internal_set_version(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Pipeline::_internal_mutable_version() {
  _has_bits_[0] |= 0x00000001u;
  return version_.Mutable(::MNN::Compression::Pipeline::_i_give_permission_to_break_this_code_default_version_, GetArenaForAllocation());
}
inline std::string* Pipeline::release_version() {
  // @@protoc_insertion_point(field_release:MNN.Compression.Pipeline.version)
  if (!_internal_has_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = version_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
  return p;
}
inline void Pipeline::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  version_.SetAllocated(nullptr, version,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.Pipeline.version)
}

// repeated .MNN.Compression.CompressionAlgo algo = 2;
inline int Pipeline::_internal_algo_size() const {
  return algo_.size();
}
inline int Pipeline::algo_size() const {
  return _internal_algo_size();
}
inline void Pipeline::clear_algo() {
  algo_.Clear();
}
inline ::MNN::Compression::CompressionAlgo* Pipeline::mutable_algo(int index) {
  // @@protoc_insertion_point(field_mutable:MNN.Compression.Pipeline.algo)
  return algo_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >*
Pipeline::mutable_algo() {
  // @@protoc_insertion_point(field_mutable_list:MNN.Compression.Pipeline.algo)
  return &algo_;
}
inline const ::MNN::Compression::CompressionAlgo& Pipeline::_internal_algo(int index) const {
  return algo_.Get(index);
}
inline const ::MNN::Compression::CompressionAlgo& Pipeline::algo(int index) const {
  // @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.algo)
  return _internal_algo(index);
}
inline ::MNN::Compression::CompressionAlgo* Pipeline::_internal_add_algo() {
  return algo_.Add();
}
inline ::MNN::Compression::CompressionAlgo* Pipeline::add_algo() {
  ::MNN::Compression::CompressionAlgo* _add = _internal_add_algo();
  // @@protoc_insertion_point(field_add:MNN.Compression.Pipeline.algo)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MNN::Compression::CompressionAlgo >&
Pipeline::algo() const {
  // @@protoc_insertion_point(field_list:MNN.Compression.Pipeline.algo)
  return algo_;
}

// optional string mnn_uuid = 3;
inline bool Pipeline::_internal_has_mnn_uuid() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Pipeline::has_mnn_uuid() const {
  return _internal_has_mnn_uuid();
}
inline void Pipeline::clear_mnn_uuid() {
  mnn_uuid_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Pipeline::mnn_uuid() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.mnn_uuid)
  return _internal_mnn_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Pipeline::set_mnn_uuid(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 mnn_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:MNN.Compression.Pipeline.mnn_uuid)
}
inline std::string* Pipeline::mutable_mnn_uuid() {
  std::string* _s = _internal_mutable_mnn_uuid();
  // @@protoc_insertion_point(field_mutable:MNN.Compression.Pipeline.mnn_uuid)
  return _s;
}
inline const std::string& Pipeline::_internal_mnn_uuid() const {
  return mnn_uuid_.Get();
}
inline void Pipeline::_internal_set_mnn_uuid(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  mnn_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Pipeline::_internal_mutable_mnn_uuid() {
  _has_bits_[0] |= 0x00000002u;
  return mnn_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Pipeline::release_mnn_uuid() {
  // @@protoc_insertion_point(field_release:MNN.Compression.Pipeline.mnn_uuid)
  if (!_internal_has_mnn_uuid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = mnn_uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (mnn_uuid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    mnn_uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Pipeline::set_allocated_mnn_uuid(std::string* mnn_uuid) {
  if (mnn_uuid != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  mnn_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mnn_uuid,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (mnn_uuid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    mnn_uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:MNN.Compression.Pipeline.mnn_uuid)
}

// optional bool for_guide = 4 [default = false];
inline bool Pipeline::_internal_has_for_guide() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Pipeline::has_for_guide() const {
  return _internal_has_for_guide();
}
inline void Pipeline::clear_for_guide() {
  for_guide_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool Pipeline::_internal_for_guide() const {
  return for_guide_;
}
inline bool Pipeline::for_guide() const {
  // @@protoc_insertion_point(field_get:MNN.Compression.Pipeline.for_guide)
  return _internal_for_guide();
}
inline void Pipeline::_internal_set_for_guide(bool value) {
  _has_bits_[0] |= 0x00000004u;
  for_guide_ = value;
}
inline void Pipeline::set_for_guide(bool value) {
  _internal_set_for_guide(value);
  // @@protoc_insertion_point(field_set:MNN.Compression.Pipeline.for_guide)
}

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Compression
}  // namespace MNN

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::MNN::Compression::QuantizeParams_RoundMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::QuantizeParams_RoundMode>() {
  return ::MNN::Compression::QuantizeParams_RoundMode_descriptor();
}
template <> struct is_proto_enum< ::MNN::Compression::LayerQuantizeParams_QuantMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::LayerQuantizeParams_QuantMethod>() {
  return ::MNN::Compression::LayerQuantizeParams_QuantMethod_descriptor();
}
template <> struct is_proto_enum< ::MNN::Compression::PruneParams_PruneType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::PruneParams_PruneType>() {
  return ::MNN::Compression::PruneParams_PruneType_descriptor();
}
template <> struct is_proto_enum< ::MNN::Compression::CompressionAlgo_CompressionType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::MNN::Compression::CompressionAlgo_CompressionType>() {
  return ::MNN::Compression::CompressionAlgo_CompressionType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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