// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: opencv-caffe.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_opencv_2dcaffe_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_opencv_2dcaffe_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021005 < 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_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_opencv_2dcaffe_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_opencv_2dcaffe_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_opencv_2dcaffe_2eproto;
namespace opencv_caffe {
class AccuracyParameter;
struct AccuracyParameterDefaultTypeInternal;
extern AccuracyParameterDefaultTypeInternal _AccuracyParameter_default_instance_;
class ArgMaxParameter;
struct ArgMaxParameterDefaultTypeInternal;
extern ArgMaxParameterDefaultTypeInternal _ArgMaxParameter_default_instance_;
class BatchNormParameter;
struct BatchNormParameterDefaultTypeInternal;
extern BatchNormParameterDefaultTypeInternal _BatchNormParameter_default_instance_;
class BiasParameter;
struct BiasParameterDefaultTypeInternal;
extern BiasParameterDefaultTypeInternal _BiasParameter_default_instance_;
class BlobProto;
struct BlobProtoDefaultTypeInternal;
extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_;
class BlobProtoVector;
struct BlobProtoVectorDefaultTypeInternal;
extern BlobProtoVectorDefaultTypeInternal _BlobProtoVector_default_instance_;
class BlobShape;
struct BlobShapeDefaultTypeInternal;
extern BlobShapeDefaultTypeInternal _BlobShape_default_instance_;
class ConcatParameter;
struct ConcatParameterDefaultTypeInternal;
extern ConcatParameterDefaultTypeInternal _ConcatParameter_default_instance_;
class ContrastiveLossParameter;
struct ContrastiveLossParameterDefaultTypeInternal;
extern ContrastiveLossParameterDefaultTypeInternal _ContrastiveLossParameter_default_instance_;
class ConvolutionParameter;
struct ConvolutionParameterDefaultTypeInternal;
extern ConvolutionParameterDefaultTypeInternal _ConvolutionParameter_default_instance_;
class CropParameter;
struct CropParameterDefaultTypeInternal;
extern CropParameterDefaultTypeInternal _CropParameter_default_instance_;
class DataParameter;
struct DataParameterDefaultTypeInternal;
extern DataParameterDefaultTypeInternal _DataParameter_default_instance_;
class Datum;
struct DatumDefaultTypeInternal;
extern DatumDefaultTypeInternal _Datum_default_instance_;
class DetectionOutputParameter;
struct DetectionOutputParameterDefaultTypeInternal;
extern DetectionOutputParameterDefaultTypeInternal _DetectionOutputParameter_default_instance_;
class DropoutParameter;
struct DropoutParameterDefaultTypeInternal;
extern DropoutParameterDefaultTypeInternal _DropoutParameter_default_instance_;
class DummyDataParameter;
struct DummyDataParameterDefaultTypeInternal;
extern DummyDataParameterDefaultTypeInternal _DummyDataParameter_default_instance_;
class ELUParameter;
struct ELUParameterDefaultTypeInternal;
extern ELUParameterDefaultTypeInternal _ELUParameter_default_instance_;
class EltwiseParameter;
struct EltwiseParameterDefaultTypeInternal;
extern EltwiseParameterDefaultTypeInternal _EltwiseParameter_default_instance_;
class EmbedParameter;
struct EmbedParameterDefaultTypeInternal;
extern EmbedParameterDefaultTypeInternal _EmbedParameter_default_instance_;
class ExpParameter;
struct ExpParameterDefaultTypeInternal;
extern ExpParameterDefaultTypeInternal _ExpParameter_default_instance_;
class FillerParameter;
struct FillerParameterDefaultTypeInternal;
extern FillerParameterDefaultTypeInternal _FillerParameter_default_instance_;
class FlattenParameter;
struct FlattenParameterDefaultTypeInternal;
extern FlattenParameterDefaultTypeInternal _FlattenParameter_default_instance_;
class HDF5DataParameter;
struct HDF5DataParameterDefaultTypeInternal;
extern HDF5DataParameterDefaultTypeInternal _HDF5DataParameter_default_instance_;
class HDF5OutputParameter;
struct HDF5OutputParameterDefaultTypeInternal;
extern HDF5OutputParameterDefaultTypeInternal _HDF5OutputParameter_default_instance_;
class HingeLossParameter;
struct HingeLossParameterDefaultTypeInternal;
extern HingeLossParameterDefaultTypeInternal _HingeLossParameter_default_instance_;
class ImageDataParameter;
struct ImageDataParameterDefaultTypeInternal;
extern ImageDataParameterDefaultTypeInternal _ImageDataParameter_default_instance_;
class InfogainLossParameter;
struct InfogainLossParameterDefaultTypeInternal;
extern InfogainLossParameterDefaultTypeInternal _InfogainLossParameter_default_instance_;
class InnerProductParameter;
struct InnerProductParameterDefaultTypeInternal;
extern InnerProductParameterDefaultTypeInternal _InnerProductParameter_default_instance_;
class InputParameter;
struct InputParameterDefaultTypeInternal;
extern InputParameterDefaultTypeInternal _InputParameter_default_instance_;
class LRNParameter;
struct LRNParameterDefaultTypeInternal;
extern LRNParameterDefaultTypeInternal _LRNParameter_default_instance_;
class LayerParameter;
struct LayerParameterDefaultTypeInternal;
extern LayerParameterDefaultTypeInternal _LayerParameter_default_instance_;
class LogParameter;
struct LogParameterDefaultTypeInternal;
extern LogParameterDefaultTypeInternal _LogParameter_default_instance_;
class LossParameter;
struct LossParameterDefaultTypeInternal;
extern LossParameterDefaultTypeInternal _LossParameter_default_instance_;
class MVNParameter;
struct MVNParameterDefaultTypeInternal;
extern MVNParameterDefaultTypeInternal _MVNParameter_default_instance_;
class MemoryDataParameter;
struct MemoryDataParameterDefaultTypeInternal;
extern MemoryDataParameterDefaultTypeInternal _MemoryDataParameter_default_instance_;
class NetParameter;
struct NetParameterDefaultTypeInternal;
extern NetParameterDefaultTypeInternal _NetParameter_default_instance_;
class NetState;
struct NetStateDefaultTypeInternal;
extern NetStateDefaultTypeInternal _NetState_default_instance_;
class NetStateRule;
struct NetStateRuleDefaultTypeInternal;
extern NetStateRuleDefaultTypeInternal _NetStateRule_default_instance_;
class NonMaximumSuppressionParameter;
struct NonMaximumSuppressionParameterDefaultTypeInternal;
extern NonMaximumSuppressionParameterDefaultTypeInternal _NonMaximumSuppressionParameter_default_instance_;
class NormalizeBBoxParameter;
struct NormalizeBBoxParameterDefaultTypeInternal;
extern NormalizeBBoxParameterDefaultTypeInternal _NormalizeBBoxParameter_default_instance_;
class NormalizedBBox;
struct NormalizedBBoxDefaultTypeInternal;
extern NormalizedBBoxDefaultTypeInternal _NormalizedBBox_default_instance_;
class PReLUParameter;
struct PReLUParameterDefaultTypeInternal;
extern PReLUParameterDefaultTypeInternal _PReLUParameter_default_instance_;
class PSROIPoolingParameter;
struct PSROIPoolingParameterDefaultTypeInternal;
extern PSROIPoolingParameterDefaultTypeInternal _PSROIPoolingParameter_default_instance_;
class ParamSpec;
struct ParamSpecDefaultTypeInternal;
extern ParamSpecDefaultTypeInternal _ParamSpec_default_instance_;
class ParameterParameter;
struct ParameterParameterDefaultTypeInternal;
extern ParameterParameterDefaultTypeInternal _ParameterParameter_default_instance_;
class PermuteParameter;
struct PermuteParameterDefaultTypeInternal;
extern PermuteParameterDefaultTypeInternal _PermuteParameter_default_instance_;
class PoolingParameter;
struct PoolingParameterDefaultTypeInternal;
extern PoolingParameterDefaultTypeInternal _PoolingParameter_default_instance_;
class PowerParameter;
struct PowerParameterDefaultTypeInternal;
extern PowerParameterDefaultTypeInternal _PowerParameter_default_instance_;
class PriorBoxParameter;
struct PriorBoxParameterDefaultTypeInternal;
extern PriorBoxParameterDefaultTypeInternal _PriorBoxParameter_default_instance_;
class ProposalParameter;
struct ProposalParameterDefaultTypeInternal;
extern ProposalParameterDefaultTypeInternal _ProposalParameter_default_instance_;
class PythonParameter;
struct PythonParameterDefaultTypeInternal;
extern PythonParameterDefaultTypeInternal _PythonParameter_default_instance_;
class ROIPoolingParameter;
struct ROIPoolingParameterDefaultTypeInternal;
extern ROIPoolingParameterDefaultTypeInternal _ROIPoolingParameter_default_instance_;
class ReLUParameter;
struct ReLUParameterDefaultTypeInternal;
extern ReLUParameterDefaultTypeInternal _ReLUParameter_default_instance_;
class RecurrentParameter;
struct RecurrentParameterDefaultTypeInternal;
extern RecurrentParameterDefaultTypeInternal _RecurrentParameter_default_instance_;
class ReductionParameter;
struct ReductionParameterDefaultTypeInternal;
extern ReductionParameterDefaultTypeInternal _ReductionParameter_default_instance_;
class ReshapeParameter;
struct ReshapeParameterDefaultTypeInternal;
extern ReshapeParameterDefaultTypeInternal _ReshapeParameter_default_instance_;
class SPPParameter;
struct SPPParameterDefaultTypeInternal;
extern SPPParameterDefaultTypeInternal _SPPParameter_default_instance_;
class SaveOutputParameter;
struct SaveOutputParameterDefaultTypeInternal;
extern SaveOutputParameterDefaultTypeInternal _SaveOutputParameter_default_instance_;
class ScaleParameter;
struct ScaleParameterDefaultTypeInternal;
extern ScaleParameterDefaultTypeInternal _ScaleParameter_default_instance_;
class SigmoidParameter;
struct SigmoidParameterDefaultTypeInternal;
extern SigmoidParameterDefaultTypeInternal _SigmoidParameter_default_instance_;
class SliceParameter;
struct SliceParameterDefaultTypeInternal;
extern SliceParameterDefaultTypeInternal _SliceParameter_default_instance_;
class SoftmaxParameter;
struct SoftmaxParameterDefaultTypeInternal;
extern SoftmaxParameterDefaultTypeInternal _SoftmaxParameter_default_instance_;
class SolverParameter;
struct SolverParameterDefaultTypeInternal;
extern SolverParameterDefaultTypeInternal _SolverParameter_default_instance_;
class SolverState;
struct SolverStateDefaultTypeInternal;
extern SolverStateDefaultTypeInternal _SolverState_default_instance_;
class TanHParameter;
struct TanHParameterDefaultTypeInternal;
extern TanHParameterDefaultTypeInternal _TanHParameter_default_instance_;
class ThresholdParameter;
struct ThresholdParameterDefaultTypeInternal;
extern ThresholdParameterDefaultTypeInternal _ThresholdParameter_default_instance_;
class TileParameter;
struct TileParameterDefaultTypeInternal;
extern TileParameterDefaultTypeInternal _TileParameter_default_instance_;
class TransformationParameter;
struct TransformationParameterDefaultTypeInternal;
extern TransformationParameterDefaultTypeInternal _TransformationParameter_default_instance_;
class V0LayerParameter;
struct V0LayerParameterDefaultTypeInternal;
extern V0LayerParameterDefaultTypeInternal _V0LayerParameter_default_instance_;
class V1LayerParameter;
struct V1LayerParameterDefaultTypeInternal;
extern V1LayerParameterDefaultTypeInternal _V1LayerParameter_default_instance_;
class WindowDataParameter;
struct WindowDataParameterDefaultTypeInternal;
extern WindowDataParameterDefaultTypeInternal _WindowDataParameter_default_instance_;
}  // namespace opencv_caffe
PROTOBUF_NAMESPACE_OPEN
template<> ::opencv_caffe::AccuracyParameter* Arena::CreateMaybeMessage<::opencv_caffe::AccuracyParameter>(Arena*);
template<> ::opencv_caffe::ArgMaxParameter* Arena::CreateMaybeMessage<::opencv_caffe::ArgMaxParameter>(Arena*);
template<> ::opencv_caffe::BatchNormParameter* Arena::CreateMaybeMessage<::opencv_caffe::BatchNormParameter>(Arena*);
template<> ::opencv_caffe::BiasParameter* Arena::CreateMaybeMessage<::opencv_caffe::BiasParameter>(Arena*);
template<> ::opencv_caffe::BlobProto* Arena::CreateMaybeMessage<::opencv_caffe::BlobProto>(Arena*);
template<> ::opencv_caffe::BlobProtoVector* Arena::CreateMaybeMessage<::opencv_caffe::BlobProtoVector>(Arena*);
template<> ::opencv_caffe::BlobShape* Arena::CreateMaybeMessage<::opencv_caffe::BlobShape>(Arena*);
template<> ::opencv_caffe::ConcatParameter* Arena::CreateMaybeMessage<::opencv_caffe::ConcatParameter>(Arena*);
template<> ::opencv_caffe::ContrastiveLossParameter* Arena::CreateMaybeMessage<::opencv_caffe::ContrastiveLossParameter>(Arena*);
template<> ::opencv_caffe::ConvolutionParameter* Arena::CreateMaybeMessage<::opencv_caffe::ConvolutionParameter>(Arena*);
template<> ::opencv_caffe::CropParameter* Arena::CreateMaybeMessage<::opencv_caffe::CropParameter>(Arena*);
template<> ::opencv_caffe::DataParameter* Arena::CreateMaybeMessage<::opencv_caffe::DataParameter>(Arena*);
template<> ::opencv_caffe::Datum* Arena::CreateMaybeMessage<::opencv_caffe::Datum>(Arena*);
template<> ::opencv_caffe::DetectionOutputParameter* Arena::CreateMaybeMessage<::opencv_caffe::DetectionOutputParameter>(Arena*);
template<> ::opencv_caffe::DropoutParameter* Arena::CreateMaybeMessage<::opencv_caffe::DropoutParameter>(Arena*);
template<> ::opencv_caffe::DummyDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::DummyDataParameter>(Arena*);
template<> ::opencv_caffe::ELUParameter* Arena::CreateMaybeMessage<::opencv_caffe::ELUParameter>(Arena*);
template<> ::opencv_caffe::EltwiseParameter* Arena::CreateMaybeMessage<::opencv_caffe::EltwiseParameter>(Arena*);
template<> ::opencv_caffe::EmbedParameter* Arena::CreateMaybeMessage<::opencv_caffe::EmbedParameter>(Arena*);
template<> ::opencv_caffe::ExpParameter* Arena::CreateMaybeMessage<::opencv_caffe::ExpParameter>(Arena*);
template<> ::opencv_caffe::FillerParameter* Arena::CreateMaybeMessage<::opencv_caffe::FillerParameter>(Arena*);
template<> ::opencv_caffe::FlattenParameter* Arena::CreateMaybeMessage<::opencv_caffe::FlattenParameter>(Arena*);
template<> ::opencv_caffe::HDF5DataParameter* Arena::CreateMaybeMessage<::opencv_caffe::HDF5DataParameter>(Arena*);
template<> ::opencv_caffe::HDF5OutputParameter* Arena::CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(Arena*);
template<> ::opencv_caffe::HingeLossParameter* Arena::CreateMaybeMessage<::opencv_caffe::HingeLossParameter>(Arena*);
template<> ::opencv_caffe::ImageDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::ImageDataParameter>(Arena*);
template<> ::opencv_caffe::InfogainLossParameter* Arena::CreateMaybeMessage<::opencv_caffe::InfogainLossParameter>(Arena*);
template<> ::opencv_caffe::InnerProductParameter* Arena::CreateMaybeMessage<::opencv_caffe::InnerProductParameter>(Arena*);
template<> ::opencv_caffe::InputParameter* Arena::CreateMaybeMessage<::opencv_caffe::InputParameter>(Arena*);
template<> ::opencv_caffe::LRNParameter* Arena::CreateMaybeMessage<::opencv_caffe::LRNParameter>(Arena*);
template<> ::opencv_caffe::LayerParameter* Arena::CreateMaybeMessage<::opencv_caffe::LayerParameter>(Arena*);
template<> ::opencv_caffe::LogParameter* Arena::CreateMaybeMessage<::opencv_caffe::LogParameter>(Arena*);
template<> ::opencv_caffe::LossParameter* Arena::CreateMaybeMessage<::opencv_caffe::LossParameter>(Arena*);
template<> ::opencv_caffe::MVNParameter* Arena::CreateMaybeMessage<::opencv_caffe::MVNParameter>(Arena*);
template<> ::opencv_caffe::MemoryDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::MemoryDataParameter>(Arena*);
template<> ::opencv_caffe::NetParameter* Arena::CreateMaybeMessage<::opencv_caffe::NetParameter>(Arena*);
template<> ::opencv_caffe::NetState* Arena::CreateMaybeMessage<::opencv_caffe::NetState>(Arena*);
template<> ::opencv_caffe::NetStateRule* Arena::CreateMaybeMessage<::opencv_caffe::NetStateRule>(Arena*);
template<> ::opencv_caffe::NonMaximumSuppressionParameter* Arena::CreateMaybeMessage<::opencv_caffe::NonMaximumSuppressionParameter>(Arena*);
template<> ::opencv_caffe::NormalizeBBoxParameter* Arena::CreateMaybeMessage<::opencv_caffe::NormalizeBBoxParameter>(Arena*);
template<> ::opencv_caffe::NormalizedBBox* Arena::CreateMaybeMessage<::opencv_caffe::NormalizedBBox>(Arena*);
template<> ::opencv_caffe::PReLUParameter* Arena::CreateMaybeMessage<::opencv_caffe::PReLUParameter>(Arena*);
template<> ::opencv_caffe::PSROIPoolingParameter* Arena::CreateMaybeMessage<::opencv_caffe::PSROIPoolingParameter>(Arena*);
template<> ::opencv_caffe::ParamSpec* Arena::CreateMaybeMessage<::opencv_caffe::ParamSpec>(Arena*);
template<> ::opencv_caffe::ParameterParameter* Arena::CreateMaybeMessage<::opencv_caffe::ParameterParameter>(Arena*);
template<> ::opencv_caffe::PermuteParameter* Arena::CreateMaybeMessage<::opencv_caffe::PermuteParameter>(Arena*);
template<> ::opencv_caffe::PoolingParameter* Arena::CreateMaybeMessage<::opencv_caffe::PoolingParameter>(Arena*);
template<> ::opencv_caffe::PowerParameter* Arena::CreateMaybeMessage<::opencv_caffe::PowerParameter>(Arena*);
template<> ::opencv_caffe::PriorBoxParameter* Arena::CreateMaybeMessage<::opencv_caffe::PriorBoxParameter>(Arena*);
template<> ::opencv_caffe::ProposalParameter* Arena::CreateMaybeMessage<::opencv_caffe::ProposalParameter>(Arena*);
template<> ::opencv_caffe::PythonParameter* Arena::CreateMaybeMessage<::opencv_caffe::PythonParameter>(Arena*);
template<> ::opencv_caffe::ROIPoolingParameter* Arena::CreateMaybeMessage<::opencv_caffe::ROIPoolingParameter>(Arena*);
template<> ::opencv_caffe::ReLUParameter* Arena::CreateMaybeMessage<::opencv_caffe::ReLUParameter>(Arena*);
template<> ::opencv_caffe::RecurrentParameter* Arena::CreateMaybeMessage<::opencv_caffe::RecurrentParameter>(Arena*);
template<> ::opencv_caffe::ReductionParameter* Arena::CreateMaybeMessage<::opencv_caffe::ReductionParameter>(Arena*);
template<> ::opencv_caffe::ReshapeParameter* Arena::CreateMaybeMessage<::opencv_caffe::ReshapeParameter>(Arena*);
template<> ::opencv_caffe::SPPParameter* Arena::CreateMaybeMessage<::opencv_caffe::SPPParameter>(Arena*);
template<> ::opencv_caffe::SaveOutputParameter* Arena::CreateMaybeMessage<::opencv_caffe::SaveOutputParameter>(Arena*);
template<> ::opencv_caffe::ScaleParameter* Arena::CreateMaybeMessage<::opencv_caffe::ScaleParameter>(Arena*);
template<> ::opencv_caffe::SigmoidParameter* Arena::CreateMaybeMessage<::opencv_caffe::SigmoidParameter>(Arena*);
template<> ::opencv_caffe::SliceParameter* Arena::CreateMaybeMessage<::opencv_caffe::SliceParameter>(Arena*);
template<> ::opencv_caffe::SoftmaxParameter* Arena::CreateMaybeMessage<::opencv_caffe::SoftmaxParameter>(Arena*);
template<> ::opencv_caffe::SolverParameter* Arena::CreateMaybeMessage<::opencv_caffe::SolverParameter>(Arena*);
template<> ::opencv_caffe::SolverState* Arena::CreateMaybeMessage<::opencv_caffe::SolverState>(Arena*);
template<> ::opencv_caffe::TanHParameter* Arena::CreateMaybeMessage<::opencv_caffe::TanHParameter>(Arena*);
template<> ::opencv_caffe::ThresholdParameter* Arena::CreateMaybeMessage<::opencv_caffe::ThresholdParameter>(Arena*);
template<> ::opencv_caffe::TileParameter* Arena::CreateMaybeMessage<::opencv_caffe::TileParameter>(Arena*);
template<> ::opencv_caffe::TransformationParameter* Arena::CreateMaybeMessage<::opencv_caffe::TransformationParameter>(Arena*);
template<> ::opencv_caffe::V0LayerParameter* Arena::CreateMaybeMessage<::opencv_caffe::V0LayerParameter>(Arena*);
template<> ::opencv_caffe::V1LayerParameter* Arena::CreateMaybeMessage<::opencv_caffe::V1LayerParameter>(Arena*);
template<> ::opencv_caffe::WindowDataParameter* Arena::CreateMaybeMessage<::opencv_caffe::WindowDataParameter>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace opencv_caffe {

enum PriorBoxParameter_CodeType : int {
  PriorBoxParameter_CodeType_CORNER = 1,
  PriorBoxParameter_CodeType_CENTER_SIZE = 2
};
bool PriorBoxParameter_CodeType_IsValid(int value);
constexpr PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MIN = PriorBoxParameter_CodeType_CORNER;
constexpr PriorBoxParameter_CodeType PriorBoxParameter_CodeType_CodeType_MAX = PriorBoxParameter_CodeType_CENTER_SIZE;
constexpr int PriorBoxParameter_CodeType_CodeType_ARRAYSIZE = PriorBoxParameter_CodeType_CodeType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PriorBoxParameter_CodeType_descriptor();
template<typename T>
inline const std::string& PriorBoxParameter_CodeType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PriorBoxParameter_CodeType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PriorBoxParameter_CodeType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PriorBoxParameter_CodeType_descriptor(), enum_t_value);
}
inline bool PriorBoxParameter_CodeType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PriorBoxParameter_CodeType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PriorBoxParameter_CodeType>(
    PriorBoxParameter_CodeType_descriptor(), name, value);
}
enum FillerParameter_VarianceNorm : int {
  FillerParameter_VarianceNorm_FAN_IN = 0,
  FillerParameter_VarianceNorm_FAN_OUT = 1,
  FillerParameter_VarianceNorm_AVERAGE = 2
};
bool FillerParameter_VarianceNorm_IsValid(int value);
constexpr FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MIN = FillerParameter_VarianceNorm_FAN_IN;
constexpr FillerParameter_VarianceNorm FillerParameter_VarianceNorm_VarianceNorm_MAX = FillerParameter_VarianceNorm_AVERAGE;
constexpr int FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE = FillerParameter_VarianceNorm_VarianceNorm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FillerParameter_VarianceNorm_descriptor();
template<typename T>
inline const std::string& FillerParameter_VarianceNorm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FillerParameter_VarianceNorm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FillerParameter_VarianceNorm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FillerParameter_VarianceNorm_descriptor(), enum_t_value);
}
inline bool FillerParameter_VarianceNorm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FillerParameter_VarianceNorm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FillerParameter_VarianceNorm>(
    FillerParameter_VarianceNorm_descriptor(), name, value);
}
enum SolverParameter_SnapshotFormat : int {
  SolverParameter_SnapshotFormat_HDF5 = 0,
  SolverParameter_SnapshotFormat_BINARYPROTO = 1
};
bool SolverParameter_SnapshotFormat_IsValid(int value);
constexpr SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MIN = SolverParameter_SnapshotFormat_HDF5;
constexpr SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat_SnapshotFormat_MAX = SolverParameter_SnapshotFormat_BINARYPROTO;
constexpr int SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE = SolverParameter_SnapshotFormat_SnapshotFormat_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor();
template<typename T>
inline const std::string& SolverParameter_SnapshotFormat_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SolverParameter_SnapshotFormat>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SolverParameter_SnapshotFormat_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SolverParameter_SnapshotFormat_descriptor(), enum_t_value);
}
inline bool SolverParameter_SnapshotFormat_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SnapshotFormat* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SolverParameter_SnapshotFormat>(
    SolverParameter_SnapshotFormat_descriptor(), name, value);
}
enum SolverParameter_SolverMode : int {
  SolverParameter_SolverMode_CPU = 0,
  SolverParameter_SolverMode_GPU = 1
};
bool SolverParameter_SolverMode_IsValid(int value);
constexpr SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MIN = SolverParameter_SolverMode_CPU;
constexpr SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MAX = SolverParameter_SolverMode_GPU;
constexpr int SolverParameter_SolverMode_SolverMode_ARRAYSIZE = SolverParameter_SolverMode_SolverMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverMode_descriptor();
template<typename T>
inline const std::string& SolverParameter_SolverMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SolverParameter_SolverMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SolverParameter_SolverMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SolverParameter_SolverMode_descriptor(), enum_t_value);
}
inline bool SolverParameter_SolverMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SolverMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SolverParameter_SolverMode>(
    SolverParameter_SolverMode_descriptor(), name, value);
}
enum SolverParameter_SolverType : int {
  SolverParameter_SolverType_SGD = 0,
  SolverParameter_SolverType_NESTEROV = 1,
  SolverParameter_SolverType_ADAGRAD = 2,
  SolverParameter_SolverType_RMSPROP = 3,
  SolverParameter_SolverType_ADADELTA = 4,
  SolverParameter_SolverType_ADAM = 5
};
bool SolverParameter_SolverType_IsValid(int value);
constexpr SolverParameter_SolverType SolverParameter_SolverType_SolverType_MIN = SolverParameter_SolverType_SGD;
constexpr SolverParameter_SolverType SolverParameter_SolverType_SolverType_MAX = SolverParameter_SolverType_ADAM;
constexpr int SolverParameter_SolverType_SolverType_ARRAYSIZE = SolverParameter_SolverType_SolverType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SolverParameter_SolverType_descriptor();
template<typename T>
inline const std::string& SolverParameter_SolverType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SolverParameter_SolverType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SolverParameter_SolverType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SolverParameter_SolverType_descriptor(), enum_t_value);
}
inline bool SolverParameter_SolverType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SolverParameter_SolverType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SolverParameter_SolverType>(
    SolverParameter_SolverType_descriptor(), name, value);
}
enum ParamSpec_DimCheckMode : int {
  ParamSpec_DimCheckMode_STRICT = 0,
  ParamSpec_DimCheckMode_PERMISSIVE = 1
};
bool ParamSpec_DimCheckMode_IsValid(int value);
constexpr ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MIN = ParamSpec_DimCheckMode_STRICT;
constexpr ParamSpec_DimCheckMode ParamSpec_DimCheckMode_DimCheckMode_MAX = ParamSpec_DimCheckMode_PERMISSIVE;
constexpr int ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE = ParamSpec_DimCheckMode_DimCheckMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ParamSpec_DimCheckMode_descriptor();
template<typename T>
inline const std::string& ParamSpec_DimCheckMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ParamSpec_DimCheckMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ParamSpec_DimCheckMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ParamSpec_DimCheckMode_descriptor(), enum_t_value);
}
inline bool ParamSpec_DimCheckMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParamSpec_DimCheckMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ParamSpec_DimCheckMode>(
    ParamSpec_DimCheckMode_descriptor(), name, value);
}
enum LossParameter_NormalizationMode : int {
  LossParameter_NormalizationMode_FULL = 0,
  LossParameter_NormalizationMode_VALID = 1,
  LossParameter_NormalizationMode_BATCH_SIZE = 2,
  LossParameter_NormalizationMode_NONE = 3
};
bool LossParameter_NormalizationMode_IsValid(int value);
constexpr LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MIN = LossParameter_NormalizationMode_FULL;
constexpr LossParameter_NormalizationMode LossParameter_NormalizationMode_NormalizationMode_MAX = LossParameter_NormalizationMode_NONE;
constexpr int LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE = LossParameter_NormalizationMode_NormalizationMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LossParameter_NormalizationMode_descriptor();
template<typename T>
inline const std::string& LossParameter_NormalizationMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LossParameter_NormalizationMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LossParameter_NormalizationMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LossParameter_NormalizationMode_descriptor(), enum_t_value);
}
inline bool LossParameter_NormalizationMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LossParameter_NormalizationMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LossParameter_NormalizationMode>(
    LossParameter_NormalizationMode_descriptor(), name, value);
}
enum ConvolutionParameter_Engine : int {
  ConvolutionParameter_Engine_DEFAULT = 0,
  ConvolutionParameter_Engine_CAFFE = 1,
  ConvolutionParameter_Engine_CUDNN = 2
};
bool ConvolutionParameter_Engine_IsValid(int value);
constexpr ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MIN = ConvolutionParameter_Engine_DEFAULT;
constexpr ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MAX = ConvolutionParameter_Engine_CUDNN;
constexpr int ConvolutionParameter_Engine_Engine_ARRAYSIZE = ConvolutionParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConvolutionParameter_Engine_descriptor();
template<typename T>
inline const std::string& ConvolutionParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ConvolutionParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ConvolutionParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ConvolutionParameter_Engine_descriptor(), enum_t_value);
}
inline bool ConvolutionParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConvolutionParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConvolutionParameter_Engine>(
    ConvolutionParameter_Engine_descriptor(), name, value);
}
enum DataParameter_DB : int {
  DataParameter_DB_LEVELDB = 0,
  DataParameter_DB_LMDB = 1
};
bool DataParameter_DB_IsValid(int value);
constexpr DataParameter_DB DataParameter_DB_DB_MIN = DataParameter_DB_LEVELDB;
constexpr DataParameter_DB DataParameter_DB_DB_MAX = DataParameter_DB_LMDB;
constexpr int DataParameter_DB_DB_ARRAYSIZE = DataParameter_DB_DB_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataParameter_DB_descriptor();
template<typename T>
inline const std::string& DataParameter_DB_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DataParameter_DB>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DataParameter_DB_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DataParameter_DB_descriptor(), enum_t_value);
}
inline bool DataParameter_DB_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataParameter_DB* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataParameter_DB>(
    DataParameter_DB_descriptor(), name, value);
}
enum EltwiseParameter_EltwiseOp : int {
  EltwiseParameter_EltwiseOp_PROD = 0,
  EltwiseParameter_EltwiseOp_SUM = 1,
  EltwiseParameter_EltwiseOp_MAX = 2
};
bool EltwiseParameter_EltwiseOp_IsValid(int value);
constexpr EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MIN = EltwiseParameter_EltwiseOp_PROD;
constexpr EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MAX = EltwiseParameter_EltwiseOp_MAX;
constexpr int EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE = EltwiseParameter_EltwiseOp_EltwiseOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor();
template<typename T>
inline const std::string& EltwiseParameter_EltwiseOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, EltwiseParameter_EltwiseOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function EltwiseParameter_EltwiseOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    EltwiseParameter_EltwiseOp_descriptor(), enum_t_value);
}
inline bool EltwiseParameter_EltwiseOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EltwiseParameter_EltwiseOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EltwiseParameter_EltwiseOp>(
    EltwiseParameter_EltwiseOp_descriptor(), name, value);
}
enum HingeLossParameter_Norm : int {
  HingeLossParameter_Norm_L1 = 1,
  HingeLossParameter_Norm_L2 = 2
};
bool HingeLossParameter_Norm_IsValid(int value);
constexpr HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MIN = HingeLossParameter_Norm_L1;
constexpr HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MAX = HingeLossParameter_Norm_L2;
constexpr int HingeLossParameter_Norm_Norm_ARRAYSIZE = HingeLossParameter_Norm_Norm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HingeLossParameter_Norm_descriptor();
template<typename T>
inline const std::string& HingeLossParameter_Norm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HingeLossParameter_Norm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HingeLossParameter_Norm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HingeLossParameter_Norm_descriptor(), enum_t_value);
}
inline bool HingeLossParameter_Norm_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HingeLossParameter_Norm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HingeLossParameter_Norm>(
    HingeLossParameter_Norm_descriptor(), name, value);
}
enum LRNParameter_NormRegion : int {
  LRNParameter_NormRegion_ACROSS_CHANNELS = 0,
  LRNParameter_NormRegion_WITHIN_CHANNEL = 1
};
bool LRNParameter_NormRegion_IsValid(int value);
constexpr LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MIN = LRNParameter_NormRegion_ACROSS_CHANNELS;
constexpr LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MAX = LRNParameter_NormRegion_WITHIN_CHANNEL;
constexpr int LRNParameter_NormRegion_NormRegion_ARRAYSIZE = LRNParameter_NormRegion_NormRegion_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_NormRegion_descriptor();
template<typename T>
inline const std::string& LRNParameter_NormRegion_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LRNParameter_NormRegion>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LRNParameter_NormRegion_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LRNParameter_NormRegion_descriptor(), enum_t_value);
}
inline bool LRNParameter_NormRegion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LRNParameter_NormRegion* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LRNParameter_NormRegion>(
    LRNParameter_NormRegion_descriptor(), name, value);
}
enum LRNParameter_Engine : int {
  LRNParameter_Engine_DEFAULT = 0,
  LRNParameter_Engine_CAFFE = 1,
  LRNParameter_Engine_CUDNN = 2
};
bool LRNParameter_Engine_IsValid(int value);
constexpr LRNParameter_Engine LRNParameter_Engine_Engine_MIN = LRNParameter_Engine_DEFAULT;
constexpr LRNParameter_Engine LRNParameter_Engine_Engine_MAX = LRNParameter_Engine_CUDNN;
constexpr int LRNParameter_Engine_Engine_ARRAYSIZE = LRNParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LRNParameter_Engine_descriptor();
template<typename T>
inline const std::string& LRNParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LRNParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LRNParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LRNParameter_Engine_descriptor(), enum_t_value);
}
inline bool LRNParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LRNParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LRNParameter_Engine>(
    LRNParameter_Engine_descriptor(), name, value);
}
enum PoolingParameter_PoolMethod : int {
  PoolingParameter_PoolMethod_MAX = 0,
  PoolingParameter_PoolMethod_AVE = 1,
  PoolingParameter_PoolMethod_STOCHASTIC = 2
};
bool PoolingParameter_PoolMethod_IsValid(int value);
constexpr PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MIN = PoolingParameter_PoolMethod_MAX;
constexpr PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MAX = PoolingParameter_PoolMethod_STOCHASTIC;
constexpr int PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE = PoolingParameter_PoolMethod_PoolMethod_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& PoolingParameter_PoolMethod_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PoolingParameter_PoolMethod>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PoolingParameter_PoolMethod_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PoolingParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool PoolingParameter_PoolMethod_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_PoolMethod* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PoolingParameter_PoolMethod>(
    PoolingParameter_PoolMethod_descriptor(), name, value);
}
enum PoolingParameter_Engine : int {
  PoolingParameter_Engine_DEFAULT = 0,
  PoolingParameter_Engine_CAFFE = 1,
  PoolingParameter_Engine_CUDNN = 2
};
bool PoolingParameter_Engine_IsValid(int value);
constexpr PoolingParameter_Engine PoolingParameter_Engine_Engine_MIN = PoolingParameter_Engine_DEFAULT;
constexpr PoolingParameter_Engine PoolingParameter_Engine_Engine_MAX = PoolingParameter_Engine_CUDNN;
constexpr int PoolingParameter_Engine_Engine_ARRAYSIZE = PoolingParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PoolingParameter_Engine_descriptor();
template<typename T>
inline const std::string& PoolingParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PoolingParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PoolingParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PoolingParameter_Engine_descriptor(), enum_t_value);
}
inline bool PoolingParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PoolingParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PoolingParameter_Engine>(
    PoolingParameter_Engine_descriptor(), name, value);
}
enum ReductionParameter_ReductionOp : int {
  ReductionParameter_ReductionOp_SUM = 1,
  ReductionParameter_ReductionOp_ASUM = 2,
  ReductionParameter_ReductionOp_SUMSQ = 3,
  ReductionParameter_ReductionOp_MEAN = 4
};
bool ReductionParameter_ReductionOp_IsValid(int value);
constexpr ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MIN = ReductionParameter_ReductionOp_SUM;
constexpr ReductionParameter_ReductionOp ReductionParameter_ReductionOp_ReductionOp_MAX = ReductionParameter_ReductionOp_MEAN;
constexpr int ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE = ReductionParameter_ReductionOp_ReductionOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReductionParameter_ReductionOp_descriptor();
template<typename T>
inline const std::string& ReductionParameter_ReductionOp_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReductionParameter_ReductionOp>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReductionParameter_ReductionOp_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ReductionParameter_ReductionOp_descriptor(), enum_t_value);
}
inline bool ReductionParameter_ReductionOp_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReductionParameter_ReductionOp* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReductionParameter_ReductionOp>(
    ReductionParameter_ReductionOp_descriptor(), name, value);
}
enum ReLUParameter_Engine : int {
  ReLUParameter_Engine_DEFAULT = 0,
  ReLUParameter_Engine_CAFFE = 1,
  ReLUParameter_Engine_CUDNN = 2
};
bool ReLUParameter_Engine_IsValid(int value);
constexpr ReLUParameter_Engine ReLUParameter_Engine_Engine_MIN = ReLUParameter_Engine_DEFAULT;
constexpr ReLUParameter_Engine ReLUParameter_Engine_Engine_MAX = ReLUParameter_Engine_CUDNN;
constexpr int ReLUParameter_Engine_Engine_ARRAYSIZE = ReLUParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReLUParameter_Engine_descriptor();
template<typename T>
inline const std::string& ReLUParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReLUParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReLUParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ReLUParameter_Engine_descriptor(), enum_t_value);
}
inline bool ReLUParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReLUParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReLUParameter_Engine>(
    ReLUParameter_Engine_descriptor(), name, value);
}
enum SigmoidParameter_Engine : int {
  SigmoidParameter_Engine_DEFAULT = 0,
  SigmoidParameter_Engine_CAFFE = 1,
  SigmoidParameter_Engine_CUDNN = 2
};
bool SigmoidParameter_Engine_IsValid(int value);
constexpr SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MIN = SigmoidParameter_Engine_DEFAULT;
constexpr SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MAX = SigmoidParameter_Engine_CUDNN;
constexpr int SigmoidParameter_Engine_Engine_ARRAYSIZE = SigmoidParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SigmoidParameter_Engine_descriptor();
template<typename T>
inline const std::string& SigmoidParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SigmoidParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SigmoidParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SigmoidParameter_Engine_descriptor(), enum_t_value);
}
inline bool SigmoidParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SigmoidParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SigmoidParameter_Engine>(
    SigmoidParameter_Engine_descriptor(), name, value);
}
enum SoftmaxParameter_Engine : int {
  SoftmaxParameter_Engine_DEFAULT = 0,
  SoftmaxParameter_Engine_CAFFE = 1,
  SoftmaxParameter_Engine_CUDNN = 2
};
bool SoftmaxParameter_Engine_IsValid(int value);
constexpr SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MIN = SoftmaxParameter_Engine_DEFAULT;
constexpr SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MAX = SoftmaxParameter_Engine_CUDNN;
constexpr int SoftmaxParameter_Engine_Engine_ARRAYSIZE = SoftmaxParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SoftmaxParameter_Engine_descriptor();
template<typename T>
inline const std::string& SoftmaxParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SoftmaxParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SoftmaxParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SoftmaxParameter_Engine_descriptor(), enum_t_value);
}
inline bool SoftmaxParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SoftmaxParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SoftmaxParameter_Engine>(
    SoftmaxParameter_Engine_descriptor(), name, value);
}
enum TanHParameter_Engine : int {
  TanHParameter_Engine_DEFAULT = 0,
  TanHParameter_Engine_CAFFE = 1,
  TanHParameter_Engine_CUDNN = 2
};
bool TanHParameter_Engine_IsValid(int value);
constexpr TanHParameter_Engine TanHParameter_Engine_Engine_MIN = TanHParameter_Engine_DEFAULT;
constexpr TanHParameter_Engine TanHParameter_Engine_Engine_MAX = TanHParameter_Engine_CUDNN;
constexpr int TanHParameter_Engine_Engine_ARRAYSIZE = TanHParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TanHParameter_Engine_descriptor();
template<typename T>
inline const std::string& TanHParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TanHParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TanHParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TanHParameter_Engine_descriptor(), enum_t_value);
}
inline bool TanHParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TanHParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TanHParameter_Engine>(
    TanHParameter_Engine_descriptor(), name, value);
}
enum SPPParameter_PoolMethod : int {
  SPPParameter_PoolMethod_MAX = 0,
  SPPParameter_PoolMethod_AVE = 1,
  SPPParameter_PoolMethod_STOCHASTIC = 2
};
bool SPPParameter_PoolMethod_IsValid(int value);
constexpr SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MIN = SPPParameter_PoolMethod_MAX;
constexpr SPPParameter_PoolMethod SPPParameter_PoolMethod_PoolMethod_MAX = SPPParameter_PoolMethod_STOCHASTIC;
constexpr int SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE = SPPParameter_PoolMethod_PoolMethod_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& SPPParameter_PoolMethod_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SPPParameter_PoolMethod>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SPPParameter_PoolMethod_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SPPParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool SPPParameter_PoolMethod_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SPPParameter_PoolMethod* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SPPParameter_PoolMethod>(
    SPPParameter_PoolMethod_descriptor(), name, value);
}
enum SPPParameter_Engine : int {
  SPPParameter_Engine_DEFAULT = 0,
  SPPParameter_Engine_CAFFE = 1,
  SPPParameter_Engine_CUDNN = 2
};
bool SPPParameter_Engine_IsValid(int value);
constexpr SPPParameter_Engine SPPParameter_Engine_Engine_MIN = SPPParameter_Engine_DEFAULT;
constexpr SPPParameter_Engine SPPParameter_Engine_Engine_MAX = SPPParameter_Engine_CUDNN;
constexpr int SPPParameter_Engine_Engine_ARRAYSIZE = SPPParameter_Engine_Engine_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SPPParameter_Engine_descriptor();
template<typename T>
inline const std::string& SPPParameter_Engine_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SPPParameter_Engine>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SPPParameter_Engine_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SPPParameter_Engine_descriptor(), enum_t_value);
}
inline bool SPPParameter_Engine_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SPPParameter_Engine* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SPPParameter_Engine>(
    SPPParameter_Engine_descriptor(), name, value);
}
enum V1LayerParameter_LayerType : int {
  V1LayerParameter_LayerType_NONE = 0,
  V1LayerParameter_LayerType_ABSVAL = 35,
  V1LayerParameter_LayerType_ACCURACY = 1,
  V1LayerParameter_LayerType_ARGMAX = 30,
  V1LayerParameter_LayerType_BNLL = 2,
  V1LayerParameter_LayerType_CONCAT = 3,
  V1LayerParameter_LayerType_CONTRASTIVE_LOSS = 37,
  V1LayerParameter_LayerType_CONVOLUTION = 4,
  V1LayerParameter_LayerType_DATA = 5,
  V1LayerParameter_LayerType_DECONVOLUTION = 39,
  V1LayerParameter_LayerType_DROPOUT = 6,
  V1LayerParameter_LayerType_DUMMY_DATA = 32,
  V1LayerParameter_LayerType_EUCLIDEAN_LOSS = 7,
  V1LayerParameter_LayerType_ELTWISE = 25,
  V1LayerParameter_LayerType_EXP = 38,
  V1LayerParameter_LayerType_FLATTEN = 8,
  V1LayerParameter_LayerType_HDF5_DATA = 9,
  V1LayerParameter_LayerType_HDF5_OUTPUT = 10,
  V1LayerParameter_LayerType_HINGE_LOSS = 28,
  V1LayerParameter_LayerType_IM2COL = 11,
  V1LayerParameter_LayerType_IMAGE_DATA = 12,
  V1LayerParameter_LayerType_INFOGAIN_LOSS = 13,
  V1LayerParameter_LayerType_INNER_PRODUCT = 14,
  V1LayerParameter_LayerType_LRN = 15,
  V1LayerParameter_LayerType_MEMORY_DATA = 29,
  V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS = 16,
  V1LayerParameter_LayerType_MVN = 34,
  V1LayerParameter_LayerType_POOLING = 17,
  V1LayerParameter_LayerType_POWER = 26,
  V1LayerParameter_LayerType_RELU = 18,
  V1LayerParameter_LayerType_SIGMOID = 19,
  V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS = 27,
  V1LayerParameter_LayerType_SILENCE = 36,
  V1LayerParameter_LayerType_SOFTMAX = 20,
  V1LayerParameter_LayerType_SOFTMAX_LOSS = 21,
  V1LayerParameter_LayerType_SPLIT = 22,
  V1LayerParameter_LayerType_SLICE = 33,
  V1LayerParameter_LayerType_TANH = 23,
  V1LayerParameter_LayerType_WINDOW_DATA = 24,
  V1LayerParameter_LayerType_THRESHOLD = 31
};
bool V1LayerParameter_LayerType_IsValid(int value);
constexpr V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MIN = V1LayerParameter_LayerType_NONE;
constexpr V1LayerParameter_LayerType V1LayerParameter_LayerType_LayerType_MAX = V1LayerParameter_LayerType_DECONVOLUTION;
constexpr int V1LayerParameter_LayerType_LayerType_ARRAYSIZE = V1LayerParameter_LayerType_LayerType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_LayerType_descriptor();
template<typename T>
inline const std::string& V1LayerParameter_LayerType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, V1LayerParameter_LayerType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function V1LayerParameter_LayerType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    V1LayerParameter_LayerType_descriptor(), enum_t_value);
}
inline bool V1LayerParameter_LayerType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1LayerParameter_LayerType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<V1LayerParameter_LayerType>(
    V1LayerParameter_LayerType_descriptor(), name, value);
}
enum V1LayerParameter_DimCheckMode : int {
  V1LayerParameter_DimCheckMode_STRICT = 0,
  V1LayerParameter_DimCheckMode_PERMISSIVE = 1
};
bool V1LayerParameter_DimCheckMode_IsValid(int value);
constexpr V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MIN = V1LayerParameter_DimCheckMode_STRICT;
constexpr V1LayerParameter_DimCheckMode V1LayerParameter_DimCheckMode_DimCheckMode_MAX = V1LayerParameter_DimCheckMode_PERMISSIVE;
constexpr int V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE = V1LayerParameter_DimCheckMode_DimCheckMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor();
template<typename T>
inline const std::string& V1LayerParameter_DimCheckMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, V1LayerParameter_DimCheckMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function V1LayerParameter_DimCheckMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    V1LayerParameter_DimCheckMode_descriptor(), enum_t_value);
}
inline bool V1LayerParameter_DimCheckMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1LayerParameter_DimCheckMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<V1LayerParameter_DimCheckMode>(
    V1LayerParameter_DimCheckMode_descriptor(), name, value);
}
enum V0LayerParameter_PoolMethod : int {
  V0LayerParameter_PoolMethod_MAX = 0,
  V0LayerParameter_PoolMethod_AVE = 1,
  V0LayerParameter_PoolMethod_STOCHASTIC = 2
};
bool V0LayerParameter_PoolMethod_IsValid(int value);
constexpr V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MIN = V0LayerParameter_PoolMethod_MAX;
constexpr V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MAX = V0LayerParameter_PoolMethod_STOCHASTIC;
constexpr int V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE = V0LayerParameter_PoolMethod_PoolMethod_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor();
template<typename T>
inline const std::string& V0LayerParameter_PoolMethod_Name(T enum_t_value) {
  static_assert(::std::is_same<T, V0LayerParameter_PoolMethod>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function V0LayerParameter_PoolMethod_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    V0LayerParameter_PoolMethod_descriptor(), enum_t_value);
}
inline bool V0LayerParameter_PoolMethod_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V0LayerParameter_PoolMethod* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<V0LayerParameter_PoolMethod>(
    V0LayerParameter_PoolMethod_descriptor(), name, value);
}
enum Type : int {
  DOUBLE = 0,
  FLOAT = 1,
  FLOAT16 = 2,
  INT = 3,
  UINT = 4
};
bool Type_IsValid(int value);
constexpr Type Type_MIN = DOUBLE;
constexpr Type Type_MAX = UINT;
constexpr int Type_ARRAYSIZE = Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_descriptor();
template<typename T>
inline const std::string& Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Type_descriptor(), enum_t_value);
}
inline bool Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Type>(
    Type_descriptor(), name, value);
}
enum Phase : int {
  TRAIN = 0,
  TEST = 1
};
bool Phase_IsValid(int value);
constexpr Phase Phase_MIN = TRAIN;
constexpr Phase Phase_MAX = TEST;
constexpr int Phase_ARRAYSIZE = Phase_MAX + 1;

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

class BlobShape final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobShape) */ {
 public:
  inline BlobShape() : BlobShape(nullptr) {}
  ~BlobShape() override;
  explicit PROTOBUF_CONSTEXPR BlobShape(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BlobShape& operator=(const BlobShape& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlobShape& operator=(BlobShape&& 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 BlobShape& default_instance() {
    return *internal_default_instance();
  }
  static inline const BlobShape* internal_default_instance() {
    return reinterpret_cast<const BlobShape*>(
               &_BlobShape_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(BlobShape& a, BlobShape& b) {
    a.Swap(&b);
  }
  inline void Swap(BlobShape* 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(BlobShape* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BlobShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BlobShape>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BlobShape& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BlobShape& from) {
    BlobShape::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BlobShape* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.BlobShape";
  }
  protected:
  explicit BlobShape(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kDimFieldNumber = 1,
  };
  // repeated int64 dim = 1 [packed = true];
  int dim_size() const;
  private:
  int _internal_dim_size() const;
  public:
  void clear_dim();
  private:
  int64_t _internal_dim(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_dim() const;
  void _internal_add_dim(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_dim();
  public:
  int64_t dim(int index) const;
  void set_dim(int index, int64_t value);
  void add_dim(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      dim() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_dim();

  // @@protoc_insertion_point(class_scope:opencv_caffe.BlobShape)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > dim_;
    mutable std::atomic<int> _dim_cached_byte_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class BlobProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobProto) */ {
 public:
  inline BlobProto() : BlobProto(nullptr) {}
  ~BlobProto() override;
  explicit PROTOBUF_CONSTEXPR BlobProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BlobProto& operator=(const BlobProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlobProto& operator=(BlobProto&& 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 BlobProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const BlobProto* internal_default_instance() {
    return reinterpret_cast<const BlobProto*>(
               &_BlobProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(BlobProto& a, BlobProto& b) {
    a.Swap(&b);
  }
  inline void Swap(BlobProto* 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(BlobProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BlobProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BlobProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BlobProto& from) {
    BlobProto::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BlobProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.BlobProto";
  }
  protected:
  explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kDataFieldNumber = 5,
    kDiffFieldNumber = 6,
    kDoubleDataFieldNumber = 8,
    kDoubleDiffFieldNumber = 9,
    kRawDataFieldNumber = 12,
    kShapeFieldNumber = 7,
    kNumFieldNumber = 1,
    kChannelsFieldNumber = 2,
    kHeightFieldNumber = 3,
    kWidthFieldNumber = 4,
    kRawDataTypeFieldNumber = 10,
  };
  // repeated float data = 5 [packed = true];
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  float _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_data() const;
  void _internal_add_data(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_data();
  public:
  float data(int index) const;
  void set_data(int index, float value);
  void add_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_data();

  // repeated float diff = 6 [packed = true];
  int diff_size() const;
  private:
  int _internal_diff_size() const;
  public:
  void clear_diff();
  private:
  float _internal_diff(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_diff() const;
  void _internal_add_diff(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_diff();
  public:
  float diff(int index) const;
  void set_diff(int index, float value);
  void add_diff(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      diff() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_diff();

  // repeated double double_data = 8 [packed = true];
  int double_data_size() const;
  private:
  int _internal_double_data_size() const;
  public:
  void clear_double_data();
  private:
  double _internal_double_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_double_data() const;
  void _internal_add_double_data(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_double_data();
  public:
  double double_data(int index) const;
  void set_double_data(int index, double value);
  void add_double_data(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      double_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_double_data();

  // repeated double double_diff = 9 [packed = true];
  int double_diff_size() const;
  private:
  int _internal_double_diff_size() const;
  public:
  void clear_double_diff();
  private:
  double _internal_double_diff(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_double_diff() const;
  void _internal_add_double_diff(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_double_diff();
  public:
  double double_diff(int index) const;
  void set_double_diff(int index, double value);
  void add_double_diff(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      double_diff() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_double_diff();

  // optional bytes raw_data = 12 [packed = false];
  bool has_raw_data() const;
  private:
  bool _internal_has_raw_data() const;
  public:
  void clear_raw_data();
  const std::string& raw_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_raw_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_raw_data();
  PROTOBUF_NODISCARD std::string* release_raw_data();
  void set_allocated_raw_data(std::string* raw_data);
  private:
  const std::string& _internal_raw_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value);
  std::string* _internal_mutable_raw_data();
  public:

  // optional .opencv_caffe.BlobShape shape = 7;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::opencv_caffe::BlobShape& shape() const;
  PROTOBUF_NODISCARD ::opencv_caffe::BlobShape* release_shape();
  ::opencv_caffe::BlobShape* mutable_shape();
  void set_allocated_shape(::opencv_caffe::BlobShape* shape);
  private:
  const ::opencv_caffe::BlobShape& _internal_shape() const;
  ::opencv_caffe::BlobShape* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::opencv_caffe::BlobShape* shape);
  ::opencv_caffe::BlobShape* unsafe_arena_release_shape();

  // optional int32 num = 1 [default = 0];
  bool has_num() const;
  private:
  bool _internal_has_num() const;
  public:
  void clear_num();
  int32_t num() const;
  void set_num(int32_t value);
  private:
  int32_t _internal_num() const;
  void _internal_set_num(int32_t value);
  public:

  // optional int32 channels = 2 [default = 0];
  bool has_channels() const;
  private:
  bool _internal_has_channels() const;
  public:
  void clear_channels();
  int32_t channels() const;
  void set_channels(int32_t value);
  private:
  int32_t _internal_channels() const;
  void _internal_set_channels(int32_t value);
  public:

  // optional int32 height = 3 [default = 0];
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  int32_t height() const;
  void set_height(int32_t value);
  private:
  int32_t _internal_height() const;
  void _internal_set_height(int32_t value);
  public:

  // optional int32 width = 4 [default = 0];
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  int32_t width() const;
  void set_width(int32_t value);
  private:
  int32_t _internal_width() const;
  void _internal_set_width(int32_t value);
  public:

  // optional .opencv_caffe.Type raw_data_type = 10;
  bool has_raw_data_type() const;
  private:
  bool _internal_has_raw_data_type() const;
  public:
  void clear_raw_data_type();
  ::opencv_caffe::Type raw_data_type() const;
  void set_raw_data_type(::opencv_caffe::Type value);
  private:
  ::opencv_caffe::Type _internal_raw_data_type() const;
  void _internal_set_raw_data_type(::opencv_caffe::Type value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.BlobProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > diff_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_diff_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
    ::opencv_caffe::BlobShape* shape_;
    int32_t num_;
    int32_t channels_;
    int32_t height_;
    int32_t width_;
    int raw_data_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class BlobProtoVector final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BlobProtoVector) */ {
 public:
  inline BlobProtoVector() : BlobProtoVector(nullptr) {}
  ~BlobProtoVector() override;
  explicit PROTOBUF_CONSTEXPR BlobProtoVector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BlobProtoVector& operator=(const BlobProtoVector& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlobProtoVector& operator=(BlobProtoVector&& 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 BlobProtoVector& default_instance() {
    return *internal_default_instance();
  }
  static inline const BlobProtoVector* internal_default_instance() {
    return reinterpret_cast<const BlobProtoVector*>(
               &_BlobProtoVector_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(BlobProtoVector& a, BlobProtoVector& b) {
    a.Swap(&b);
  }
  inline void Swap(BlobProtoVector* 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(BlobProtoVector* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BlobProtoVector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BlobProtoVector>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BlobProtoVector& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BlobProtoVector& from) {
    BlobProtoVector::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BlobProtoVector* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.BlobProtoVector";
  }
  protected:
  explicit BlobProtoVector(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kBlobsFieldNumber = 1,
  };
  // repeated .opencv_caffe.BlobProto blobs = 1;
  int blobs_size() const;
  private:
  int _internal_blobs_size() const;
  public:
  void clear_blobs();
  ::opencv_caffe::BlobProto* mutable_blobs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
      mutable_blobs();
  private:
  const ::opencv_caffe::BlobProto& _internal_blobs(int index) const;
  ::opencv_caffe::BlobProto* _internal_add_blobs();
  public:
  const ::opencv_caffe::BlobProto& blobs(int index) const;
  ::opencv_caffe::BlobProto* add_blobs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
      blobs() const;

  // @@protoc_insertion_point(class_scope:opencv_caffe.BlobProtoVector)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PermuteParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PermuteParameter) */ {
 public:
  inline PermuteParameter() : PermuteParameter(nullptr) {}
  ~PermuteParameter() override;
  explicit PROTOBUF_CONSTEXPR PermuteParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PermuteParameter& operator=(const PermuteParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PermuteParameter& operator=(PermuteParameter&& 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 PermuteParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PermuteParameter* internal_default_instance() {
    return reinterpret_cast<const PermuteParameter*>(
               &_PermuteParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(PermuteParameter& a, PermuteParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PermuteParameter* 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(PermuteParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PermuteParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PermuteParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PermuteParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PermuteParameter& from) {
    PermuteParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PermuteParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PermuteParameter";
  }
  protected:
  explicit PermuteParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kOrderFieldNumber = 1,
  };
  // repeated uint32 order = 1;
  int order_size() const;
  private:
  int _internal_order_size() const;
  public:
  void clear_order();
  private:
  uint32_t _internal_order(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_order() const;
  void _internal_add_order(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_order();
  public:
  uint32_t order(int index) const;
  void set_order(int index, uint32_t value);
  void add_order(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      order() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_order();

  // @@protoc_insertion_point(class_scope:opencv_caffe.PermuteParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > order_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class NormalizeBBoxParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NormalizeBBoxParameter) */ {
 public:
  inline NormalizeBBoxParameter() : NormalizeBBoxParameter(nullptr) {}
  ~NormalizeBBoxParameter() override;
  explicit PROTOBUF_CONSTEXPR NormalizeBBoxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline NormalizeBBoxParameter& operator=(const NormalizeBBoxParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline NormalizeBBoxParameter& operator=(NormalizeBBoxParameter&& 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 NormalizeBBoxParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const NormalizeBBoxParameter* internal_default_instance() {
    return reinterpret_cast<const NormalizeBBoxParameter*>(
               &_NormalizeBBoxParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(NormalizeBBoxParameter& a, NormalizeBBoxParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(NormalizeBBoxParameter* 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(NormalizeBBoxParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NormalizeBBoxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NormalizeBBoxParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NormalizeBBoxParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NormalizeBBoxParameter& from) {
    NormalizeBBoxParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NormalizeBBoxParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.NormalizeBBoxParameter";
  }
  protected:
  explicit NormalizeBBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kScaleFillerFieldNumber = 2,
    kAcrossSpatialFieldNumber = 1,
    kChannelSharedFieldNumber = 3,
    kEpsFieldNumber = 4,
  };
  // optional .opencv_caffe.FillerParameter scale_filler = 2;
  bool has_scale_filler() const;
  private:
  bool _internal_has_scale_filler() const;
  public:
  void clear_scale_filler();
  const ::opencv_caffe::FillerParameter& scale_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_scale_filler();
  ::opencv_caffe::FillerParameter* mutable_scale_filler();
  void set_allocated_scale_filler(::opencv_caffe::FillerParameter* scale_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_scale_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_scale_filler();
  public:
  void unsafe_arena_set_allocated_scale_filler(
      ::opencv_caffe::FillerParameter* scale_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_scale_filler();

  // optional bool across_spatial = 1 [default = true];
  bool has_across_spatial() const;
  private:
  bool _internal_has_across_spatial() const;
  public:
  void clear_across_spatial();
  bool across_spatial() const;
  void set_across_spatial(bool value);
  private:
  bool _internal_across_spatial() const;
  void _internal_set_across_spatial(bool value);
  public:

  // optional bool channel_shared = 3 [default = true];
  bool has_channel_shared() const;
  private:
  bool _internal_has_channel_shared() const;
  public:
  void clear_channel_shared();
  bool channel_shared() const;
  void set_channel_shared(bool value);
  private:
  bool _internal_channel_shared() const;
  void _internal_set_channel_shared(bool value);
  public:

  // optional float eps = 4 [default = 1e-10];
  bool has_eps() const;
  private:
  bool _internal_has_eps() const;
  public:
  void clear_eps();
  float eps() const;
  void set_eps(float value);
  private:
  float _internal_eps() const;
  void _internal_set_eps(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.NormalizeBBoxParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* scale_filler_;
    bool across_spatial_;
    bool channel_shared_;
    float eps_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PriorBoxParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PriorBoxParameter) */ {
 public:
  inline PriorBoxParameter() : PriorBoxParameter(nullptr) {}
  ~PriorBoxParameter() override;
  explicit PROTOBUF_CONSTEXPR PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PriorBoxParameter& operator=(const PriorBoxParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PriorBoxParameter& operator=(PriorBoxParameter&& 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 PriorBoxParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PriorBoxParameter* internal_default_instance() {
    return reinterpret_cast<const PriorBoxParameter*>(
               &_PriorBoxParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(PriorBoxParameter& a, PriorBoxParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PriorBoxParameter* 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(PriorBoxParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PriorBoxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PriorBoxParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PriorBoxParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PriorBoxParameter& from) {
    PriorBoxParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PriorBoxParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PriorBoxParameter";
  }
  protected:
  explicit PriorBoxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 PriorBoxParameter_CodeType CodeType;
  static constexpr CodeType CORNER =
    PriorBoxParameter_CodeType_CORNER;
  static constexpr CodeType CENTER_SIZE =
    PriorBoxParameter_CodeType_CENTER_SIZE;
  static inline bool CodeType_IsValid(int value) {
    return PriorBoxParameter_CodeType_IsValid(value);
  }
  static constexpr CodeType CodeType_MIN =
    PriorBoxParameter_CodeType_CodeType_MIN;
  static constexpr CodeType CodeType_MAX =
    PriorBoxParameter_CodeType_CodeType_MAX;
  static constexpr int CodeType_ARRAYSIZE =
    PriorBoxParameter_CodeType_CodeType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  CodeType_descriptor() {
    return PriorBoxParameter_CodeType_descriptor();
  }
  template<typename T>
  static inline const std::string& CodeType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CodeType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CodeType_Name.");
    return PriorBoxParameter_CodeType_Name(enum_t_value);
  }
  static inline bool CodeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CodeType* value) {
    return PriorBoxParameter_CodeType_Parse(name, value);
  }

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

  enum : int {
    kMinSizeFieldNumber = 1,
    kMaxSizeFieldNumber = 2,
    kAspectRatioFieldNumber = 3,
    kVarianceFieldNumber = 6,
    kOffsetHFieldNumber = 14,
    kOffsetWFieldNumber = 15,
    kWidthFieldNumber = 16,
    kHeightFieldNumber = 17,
    kImgSizeFieldNumber = 7,
    kImgHFieldNumber = 8,
    kImgWFieldNumber = 9,
    kStepFieldNumber = 10,
    kStepHFieldNumber = 11,
    kStepWFieldNumber = 12,
    kFlipFieldNumber = 4,
    kClipFieldNumber = 5,
    kOffsetFieldNumber = 13,
  };
  // repeated float min_size = 1;
  int min_size_size() const;
  private:
  int _internal_min_size_size() const;
  public:
  void clear_min_size();
  private:
  float _internal_min_size(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_min_size() const;
  void _internal_add_min_size(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_min_size();
  public:
  float min_size(int index) const;
  void set_min_size(int index, float value);
  void add_min_size(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      min_size() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_min_size();

  // repeated float max_size = 2;
  int max_size_size() const;
  private:
  int _internal_max_size_size() const;
  public:
  void clear_max_size();
  private:
  float _internal_max_size(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_max_size() const;
  void _internal_add_max_size(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_max_size();
  public:
  float max_size(int index) const;
  void set_max_size(int index, float value);
  void add_max_size(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      max_size() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_max_size();

  // repeated float aspect_ratio = 3;
  int aspect_ratio_size() const;
  private:
  int _internal_aspect_ratio_size() const;
  public:
  void clear_aspect_ratio();
  private:
  float _internal_aspect_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_aspect_ratio() const;
  void _internal_add_aspect_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_aspect_ratio();
  public:
  float aspect_ratio(int index) const;
  void set_aspect_ratio(int index, float value);
  void add_aspect_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      aspect_ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_aspect_ratio();

  // repeated float variance = 6;
  int variance_size() const;
  private:
  int _internal_variance_size() const;
  public:
  void clear_variance();
  private:
  float _internal_variance(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_variance() const;
  void _internal_add_variance(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_variance();
  public:
  float variance(int index) const;
  void set_variance(int index, float value);
  void add_variance(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      variance() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_variance();

  // repeated float offset_h = 14;
  int offset_h_size() const;
  private:
  int _internal_offset_h_size() const;
  public:
  void clear_offset_h();
  private:
  float _internal_offset_h(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_offset_h() const;
  void _internal_add_offset_h(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_offset_h();
  public:
  float offset_h(int index) const;
  void set_offset_h(int index, float value);
  void add_offset_h(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      offset_h() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_offset_h();

  // repeated float offset_w = 15;
  int offset_w_size() const;
  private:
  int _internal_offset_w_size() const;
  public:
  void clear_offset_w();
  private:
  float _internal_offset_w(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_offset_w() const;
  void _internal_add_offset_w(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_offset_w();
  public:
  float offset_w(int index) const;
  void set_offset_w(int index, float value);
  void add_offset_w(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      offset_w() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_offset_w();

  // repeated float width = 16;
  int width_size() const;
  private:
  int _internal_width_size() const;
  public:
  void clear_width();
  private:
  float _internal_width(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_width() const;
  void _internal_add_width(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_width();
  public:
  float width(int index) const;
  void set_width(int index, float value);
  void add_width(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      width() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_width();

  // repeated float height = 17;
  int height_size() const;
  private:
  int _internal_height_size() const;
  public:
  void clear_height();
  private:
  float _internal_height(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_height() const;
  void _internal_add_height(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_height();
  public:
  float height(int index) const;
  void set_height(int index, float value);
  void add_height(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      height() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_height();

  // optional uint32 img_size = 7;
  bool has_img_size() const;
  private:
  bool _internal_has_img_size() const;
  public:
  void clear_img_size();
  uint32_t img_size() const;
  void set_img_size(uint32_t value);
  private:
  uint32_t _internal_img_size() const;
  void _internal_set_img_size(uint32_t value);
  public:

  // optional uint32 img_h = 8;
  bool has_img_h() const;
  private:
  bool _internal_has_img_h() const;
  public:
  void clear_img_h();
  uint32_t img_h() const;
  void set_img_h(uint32_t value);
  private:
  uint32_t _internal_img_h() const;
  void _internal_set_img_h(uint32_t value);
  public:

  // optional uint32 img_w = 9;
  bool has_img_w() const;
  private:
  bool _internal_has_img_w() const;
  public:
  void clear_img_w();
  uint32_t img_w() const;
  void set_img_w(uint32_t value);
  private:
  uint32_t _internal_img_w() const;
  void _internal_set_img_w(uint32_t value);
  public:

  // optional float step = 10;
  bool has_step() const;
  private:
  bool _internal_has_step() const;
  public:
  void clear_step();
  float step() const;
  void set_step(float value);
  private:
  float _internal_step() const;
  void _internal_set_step(float value);
  public:

  // optional float step_h = 11;
  bool has_step_h() const;
  private:
  bool _internal_has_step_h() const;
  public:
  void clear_step_h();
  float step_h() const;
  void set_step_h(float value);
  private:
  float _internal_step_h() const;
  void _internal_set_step_h(float value);
  public:

  // optional float step_w = 12;
  bool has_step_w() const;
  private:
  bool _internal_has_step_w() const;
  public:
  void clear_step_w();
  float step_w() const;
  void set_step_w(float value);
  private:
  float _internal_step_w() const;
  void _internal_set_step_w(float value);
  public:

  // optional bool flip = 4 [default = true];
  bool has_flip() const;
  private:
  bool _internal_has_flip() const;
  public:
  void clear_flip();
  bool flip() const;
  void set_flip(bool value);
  private:
  bool _internal_flip() const;
  void _internal_set_flip(bool value);
  public:

  // optional bool clip = 5 [default = true];
  bool has_clip() const;
  private:
  bool _internal_has_clip() const;
  public:
  void clear_clip();
  bool clip() const;
  void set_clip(bool value);
  private:
  bool _internal_clip() const;
  void _internal_set_clip(bool value);
  public:

  // optional float offset = 13 [default = 0.5];
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  float offset() const;
  void set_offset(float value);
  private:
  float _internal_offset() const;
  void _internal_set_offset(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.PriorBoxParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > min_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > max_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > aspect_ratio_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > variance_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > offset_h_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > offset_w_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > width_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > height_;
    uint32_t img_size_;
    uint32_t img_h_;
    uint32_t img_w_;
    float step_;
    float step_h_;
    float step_w_;
    bool flip_;
    bool clip_;
    float offset_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class DetectionOutputParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DetectionOutputParameter) */ {
 public:
  inline DetectionOutputParameter() : DetectionOutputParameter(nullptr) {}
  ~DetectionOutputParameter() override;
  explicit PROTOBUF_CONSTEXPR DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DetectionOutputParameter& operator=(const DetectionOutputParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline DetectionOutputParameter& operator=(DetectionOutputParameter&& 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 DetectionOutputParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const DetectionOutputParameter* internal_default_instance() {
    return reinterpret_cast<const DetectionOutputParameter*>(
               &_DetectionOutputParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(DetectionOutputParameter& a, DetectionOutputParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(DetectionOutputParameter* 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(DetectionOutputParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DetectionOutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DetectionOutputParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DetectionOutputParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DetectionOutputParameter& from) {
    DetectionOutputParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DetectionOutputParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.DetectionOutputParameter";
  }
  protected:
  explicit DetectionOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kNmsParamFieldNumber = 4,
    kSaveOutputParamFieldNumber = 5,
    kNumClassesFieldNumber = 1,
    kBackgroundLabelIdFieldNumber = 3,
    kConfidenceThresholdFieldNumber = 9,
    kVarianceEncodedInTargetFieldNumber = 8,
    kClipFieldNumber = 1000,
    kKeepTopKFieldNumber = 7,
    kCodeTypeFieldNumber = 6,
    kShareLocationFieldNumber = 2,
    kNormalizedBboxFieldNumber = 10,
  };
  // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
  bool has_nms_param() const;
  private:
  bool _internal_has_nms_param() const;
  public:
  void clear_nms_param();
  const ::opencv_caffe::NonMaximumSuppressionParameter& nms_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::NonMaximumSuppressionParameter* release_nms_param();
  ::opencv_caffe::NonMaximumSuppressionParameter* mutable_nms_param();
  void set_allocated_nms_param(::opencv_caffe::NonMaximumSuppressionParameter* nms_param);
  private:
  const ::opencv_caffe::NonMaximumSuppressionParameter& _internal_nms_param() const;
  ::opencv_caffe::NonMaximumSuppressionParameter* _internal_mutable_nms_param();
  public:
  void unsafe_arena_set_allocated_nms_param(
      ::opencv_caffe::NonMaximumSuppressionParameter* nms_param);
  ::opencv_caffe::NonMaximumSuppressionParameter* unsafe_arena_release_nms_param();

  // optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
  bool has_save_output_param() const;
  private:
  bool _internal_has_save_output_param() const;
  public:
  void clear_save_output_param();
  const ::opencv_caffe::SaveOutputParameter& save_output_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SaveOutputParameter* release_save_output_param();
  ::opencv_caffe::SaveOutputParameter* mutable_save_output_param();
  void set_allocated_save_output_param(::opencv_caffe::SaveOutputParameter* save_output_param);
  private:
  const ::opencv_caffe::SaveOutputParameter& _internal_save_output_param() const;
  ::opencv_caffe::SaveOutputParameter* _internal_mutable_save_output_param();
  public:
  void unsafe_arena_set_allocated_save_output_param(
      ::opencv_caffe::SaveOutputParameter* save_output_param);
  ::opencv_caffe::SaveOutputParameter* unsafe_arena_release_save_output_param();

  // optional uint32 num_classes = 1;
  bool has_num_classes() const;
  private:
  bool _internal_has_num_classes() const;
  public:
  void clear_num_classes();
  uint32_t num_classes() const;
  void set_num_classes(uint32_t value);
  private:
  uint32_t _internal_num_classes() const;
  void _internal_set_num_classes(uint32_t value);
  public:

  // optional int32 background_label_id = 3 [default = 0];
  bool has_background_label_id() const;
  private:
  bool _internal_has_background_label_id() const;
  public:
  void clear_background_label_id();
  int32_t background_label_id() const;
  void set_background_label_id(int32_t value);
  private:
  int32_t _internal_background_label_id() const;
  void _internal_set_background_label_id(int32_t value);
  public:

  // optional float confidence_threshold = 9;
  bool has_confidence_threshold() const;
  private:
  bool _internal_has_confidence_threshold() const;
  public:
  void clear_confidence_threshold();
  float confidence_threshold() const;
  void set_confidence_threshold(float value);
  private:
  float _internal_confidence_threshold() const;
  void _internal_set_confidence_threshold(float value);
  public:

  // optional bool variance_encoded_in_target = 8 [default = false];
  bool has_variance_encoded_in_target() const;
  private:
  bool _internal_has_variance_encoded_in_target() const;
  public:
  void clear_variance_encoded_in_target();
  bool variance_encoded_in_target() const;
  void set_variance_encoded_in_target(bool value);
  private:
  bool _internal_variance_encoded_in_target() const;
  void _internal_set_variance_encoded_in_target(bool value);
  public:

  // optional bool clip = 1000 [default = false];
  bool has_clip() const;
  private:
  bool _internal_has_clip() const;
  public:
  void clear_clip();
  bool clip() const;
  void set_clip(bool value);
  private:
  bool _internal_clip() const;
  void _internal_set_clip(bool value);
  public:

  // optional int32 keep_top_k = 7 [default = -1];
  bool has_keep_top_k() const;
  private:
  bool _internal_has_keep_top_k() const;
  public:
  void clear_keep_top_k();
  int32_t keep_top_k() const;
  void set_keep_top_k(int32_t value);
  private:
  int32_t _internal_keep_top_k() const;
  void _internal_set_keep_top_k(int32_t value);
  public:

  // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
  bool has_code_type() const;
  private:
  bool _internal_has_code_type() const;
  public:
  void clear_code_type();
  ::opencv_caffe::PriorBoxParameter_CodeType code_type() const;
  void set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value);
  private:
  ::opencv_caffe::PriorBoxParameter_CodeType _internal_code_type() const;
  void _internal_set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value);
  public:

  // optional bool share_location = 2 [default = true];
  bool has_share_location() const;
  private:
  bool _internal_has_share_location() const;
  public:
  void clear_share_location();
  bool share_location() const;
  void set_share_location(bool value);
  private:
  bool _internal_share_location() const;
  void _internal_set_share_location(bool value);
  public:

  // optional bool normalized_bbox = 10 [default = true];
  bool has_normalized_bbox() const;
  private:
  bool _internal_has_normalized_bbox() const;
  public:
  void clear_normalized_bbox();
  bool normalized_bbox() const;
  void set_normalized_bbox(bool value);
  private:
  bool _internal_normalized_bbox() const;
  void _internal_set_normalized_bbox(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.DetectionOutputParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::NonMaximumSuppressionParameter* nms_param_;
    ::opencv_caffe::SaveOutputParameter* save_output_param_;
    uint32_t num_classes_;
    int32_t background_label_id_;
    float confidence_threshold_;
    bool variance_encoded_in_target_;
    bool clip_;
    int32_t keep_top_k_;
    int code_type_;
    bool share_location_;
    bool normalized_bbox_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class Datum final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.Datum) */ {
 public:
  inline Datum() : Datum(nullptr) {}
  ~Datum() override;
  explicit PROTOBUF_CONSTEXPR Datum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Datum& operator=(const Datum& from) {
    CopyFrom(from);
    return *this;
  }
  inline Datum& operator=(Datum&& 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 Datum& default_instance() {
    return *internal_default_instance();
  }
  static inline const Datum* internal_default_instance() {
    return reinterpret_cast<const Datum*>(
               &_Datum_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(Datum& a, Datum& b) {
    a.Swap(&b);
  }
  inline void Swap(Datum* 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(Datum* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Datum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Datum>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Datum& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Datum& from) {
    Datum::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Datum* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.Datum";
  }
  protected:
  explicit Datum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kFloatDataFieldNumber = 6,
    kDataFieldNumber = 4,
    kChannelsFieldNumber = 1,
    kHeightFieldNumber = 2,
    kWidthFieldNumber = 3,
    kLabelFieldNumber = 5,
    kEncodedFieldNumber = 7,
  };
  // repeated float float_data = 6;
  int float_data_size() const;
  private:
  int _internal_float_data_size() const;
  public:
  void clear_float_data();
  private:
  float _internal_float_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_float_data() const;
  void _internal_add_float_data(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_float_data();
  public:
  float float_data(int index) const;
  void set_float_data(int index, float value);
  void add_float_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      float_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_float_data();

  // optional bytes data = 4;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional int32 channels = 1;
  bool has_channels() const;
  private:
  bool _internal_has_channels() const;
  public:
  void clear_channels();
  int32_t channels() const;
  void set_channels(int32_t value);
  private:
  int32_t _internal_channels() const;
  void _internal_set_channels(int32_t value);
  public:

  // optional int32 height = 2;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  int32_t height() const;
  void set_height(int32_t value);
  private:
  int32_t _internal_height() const;
  void _internal_set_height(int32_t value);
  public:

  // optional int32 width = 3;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  int32_t width() const;
  void set_width(int32_t value);
  private:
  int32_t _internal_width() const;
  void _internal_set_width(int32_t value);
  public:

  // optional int32 label = 5;
  bool has_label() const;
  private:
  bool _internal_has_label() const;
  public:
  void clear_label();
  int32_t label() const;
  void set_label(int32_t value);
  private:
  int32_t _internal_label() const;
  void _internal_set_label(int32_t value);
  public:

  // optional bool encoded = 7 [default = false];
  bool has_encoded() const;
  private:
  bool _internal_has_encoded() const;
  public:
  void clear_encoded();
  bool encoded() const;
  void set_encoded(bool value);
  private:
  bool _internal_encoded() const;
  void _internal_set_encoded(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.Datum)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int32_t channels_;
    int32_t height_;
    int32_t width_;
    int32_t label_;
    bool encoded_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class FillerParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.FillerParameter) */ {
 public:
  inline FillerParameter() : FillerParameter(nullptr) {}
  ~FillerParameter() override;
  explicit PROTOBUF_CONSTEXPR FillerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FillerParameter& operator=(const FillerParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline FillerParameter& operator=(FillerParameter&& 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 FillerParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const FillerParameter* internal_default_instance() {
    return reinterpret_cast<const FillerParameter*>(
               &_FillerParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(FillerParameter& a, FillerParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(FillerParameter* 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(FillerParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FillerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FillerParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FillerParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FillerParameter& from) {
    FillerParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FillerParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.FillerParameter";
  }
  protected:
  explicit FillerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 FillerParameter_VarianceNorm VarianceNorm;
  static constexpr VarianceNorm FAN_IN =
    FillerParameter_VarianceNorm_FAN_IN;
  static constexpr VarianceNorm FAN_OUT =
    FillerParameter_VarianceNorm_FAN_OUT;
  static constexpr VarianceNorm AVERAGE =
    FillerParameter_VarianceNorm_AVERAGE;
  static inline bool VarianceNorm_IsValid(int value) {
    return FillerParameter_VarianceNorm_IsValid(value);
  }
  static constexpr VarianceNorm VarianceNorm_MIN =
    FillerParameter_VarianceNorm_VarianceNorm_MIN;
  static constexpr VarianceNorm VarianceNorm_MAX =
    FillerParameter_VarianceNorm_VarianceNorm_MAX;
  static constexpr int VarianceNorm_ARRAYSIZE =
    FillerParameter_VarianceNorm_VarianceNorm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  VarianceNorm_descriptor() {
    return FillerParameter_VarianceNorm_descriptor();
  }
  template<typename T>
  static inline const std::string& VarianceNorm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, VarianceNorm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function VarianceNorm_Name.");
    return FillerParameter_VarianceNorm_Name(enum_t_value);
  }
  static inline bool VarianceNorm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      VarianceNorm* value) {
    return FillerParameter_VarianceNorm_Parse(name, value);
  }

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

  enum : int {
    kTypeFieldNumber = 1,
    kValueFieldNumber = 2,
    kMinFieldNumber = 3,
    kMeanFieldNumber = 5,
    kVarianceNormFieldNumber = 8,
    kSparseFieldNumber = 7,
    kMaxFieldNumber = 4,
    kStdFieldNumber = 6,
  };
  // optional string type = 1 [default = "constant"];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // optional float value = 2 [default = 0];
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  float value() const;
  void set_value(float value);
  private:
  float _internal_value() const;
  void _internal_set_value(float value);
  public:

  // optional float min = 3 [default = 0];
  bool has_min() const;
  private:
  bool _internal_has_min() const;
  public:
  void clear_min();
  float min() const;
  void set_min(float value);
  private:
  float _internal_min() const;
  void _internal_set_min(float value);
  public:

  // optional float mean = 5 [default = 0];
  bool has_mean() const;
  private:
  bool _internal_has_mean() const;
  public:
  void clear_mean();
  float mean() const;
  void set_mean(float value);
  private:
  float _internal_mean() const;
  void _internal_set_mean(float value);
  public:

  // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
  bool has_variance_norm() const;
  private:
  bool _internal_has_variance_norm() const;
  public:
  void clear_variance_norm();
  ::opencv_caffe::FillerParameter_VarianceNorm variance_norm() const;
  void set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value);
  private:
  ::opencv_caffe::FillerParameter_VarianceNorm _internal_variance_norm() const;
  void _internal_set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value);
  public:

  // optional int32 sparse = 7 [default = -1];
  bool has_sparse() const;
  private:
  bool _internal_has_sparse() const;
  public:
  void clear_sparse();
  int32_t sparse() const;
  void set_sparse(int32_t value);
  private:
  int32_t _internal_sparse() const;
  void _internal_set_sparse(int32_t value);
  public:

  // optional float max = 4 [default = 1];
  bool has_max() const;
  private:
  bool _internal_has_max() const;
  public:
  void clear_max();
  float max() const;
  void set_max(float value);
  private:
  float _internal_max() const;
  void _internal_set_max(float value);
  public:

  // optional float std = 6 [default = 1];
  bool has_std() const;
  private:
  bool _internal_has_std() const;
  public:
  void clear_std();
  float std() const;
  void set_std(float value);
  private:
  float _internal_std() const;
  void _internal_set_std(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.FillerParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
    float value_;
    float min_;
    float mean_;
    int variance_norm_;
    int32_t sparse_;
    float max_;
    float std_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class NetParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetParameter) */ {
 public:
  inline NetParameter() : NetParameter(nullptr) {}
  ~NetParameter() override;
  explicit PROTOBUF_CONSTEXPR NetParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline NetParameter& operator=(const NetParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetParameter& operator=(NetParameter&& 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 NetParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetParameter* internal_default_instance() {
    return reinterpret_cast<const NetParameter*>(
               &_NetParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(NetParameter& a, NetParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(NetParameter* 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(NetParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NetParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NetParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NetParameter& from) {
    NetParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NetParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.NetParameter";
  }
  protected:
  explicit NetParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kLayersFieldNumber = 2,
    kInputFieldNumber = 3,
    kInputDimFieldNumber = 4,
    kInputShapeFieldNumber = 8,
    kLayerFieldNumber = 100,
    kNameFieldNumber = 1,
    kStateFieldNumber = 6,
    kForceBackwardFieldNumber = 5,
    kDebugInfoFieldNumber = 7,
  };
  // repeated .opencv_caffe.V1LayerParameter layers = 2;
  int layers_size() const;
  private:
  int _internal_layers_size() const;
  public:
  void clear_layers();
  ::opencv_caffe::V1LayerParameter* mutable_layers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >*
      mutable_layers();
  private:
  const ::opencv_caffe::V1LayerParameter& _internal_layers(int index) const;
  ::opencv_caffe::V1LayerParameter* _internal_add_layers();
  public:
  const ::opencv_caffe::V1LayerParameter& layers(int index) const;
  ::opencv_caffe::V1LayerParameter* add_layers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >&
      layers() const;

  // repeated string input = 3;
  int input_size() const;
  private:
  int _internal_input_size() const;
  public:
  void clear_input();
  const std::string& input(int index) const;
  std::string* mutable_input(int index);
  void set_input(int index, const std::string& value);
  void set_input(int index, std::string&& value);
  void set_input(int index, const char* value);
  void set_input(int index, const char* value, size_t size);
  std::string* add_input();
  void add_input(const std::string& value);
  void add_input(std::string&& value);
  void add_input(const char* value);
  void add_input(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
  private:
  const std::string& _internal_input(int index) const;
  std::string* _internal_add_input();
  public:

  // repeated int32 input_dim = 4;
  int input_dim_size() const;
  private:
  int _internal_input_dim_size() const;
  public:
  void clear_input_dim();
  private:
  int32_t _internal_input_dim(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_input_dim() const;
  void _internal_add_input_dim(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_input_dim();
  public:
  int32_t input_dim(int index) const;
  void set_input_dim(int index, int32_t value);
  void add_input_dim(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      input_dim() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_input_dim();

  // repeated .opencv_caffe.BlobShape input_shape = 8;
  int input_shape_size() const;
  private:
  int _internal_input_shape_size() const;
  public:
  void clear_input_shape();
  ::opencv_caffe::BlobShape* mutable_input_shape(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >*
      mutable_input_shape();
  private:
  const ::opencv_caffe::BlobShape& _internal_input_shape(int index) const;
  ::opencv_caffe::BlobShape* _internal_add_input_shape();
  public:
  const ::opencv_caffe::BlobShape& input_shape(int index) const;
  ::opencv_caffe::BlobShape* add_input_shape();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >&
      input_shape() const;

  // repeated .opencv_caffe.LayerParameter layer = 100;
  int layer_size() const;
  private:
  int _internal_layer_size() const;
  public:
  void clear_layer();
  ::opencv_caffe::LayerParameter* mutable_layer(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter >*
      mutable_layer();
  private:
  const ::opencv_caffe::LayerParameter& _internal_layer(int index) const;
  ::opencv_caffe::LayerParameter* _internal_add_layer();
  public:
  const ::opencv_caffe::LayerParameter& layer(int index) const;
  ::opencv_caffe::LayerParameter* add_layer();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter >&
      layer() const;

  // optional 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 .opencv_caffe.NetState state = 6;
  bool has_state() const;
  private:
  bool _internal_has_state() const;
  public:
  void clear_state();
  const ::opencv_caffe::NetState& state() const;
  PROTOBUF_NODISCARD ::opencv_caffe::NetState* release_state();
  ::opencv_caffe::NetState* mutable_state();
  void set_allocated_state(::opencv_caffe::NetState* state);
  private:
  const ::opencv_caffe::NetState& _internal_state() const;
  ::opencv_caffe::NetState* _internal_mutable_state();
  public:
  void unsafe_arena_set_allocated_state(
      ::opencv_caffe::NetState* state);
  ::opencv_caffe::NetState* unsafe_arena_release_state();

  // optional bool force_backward = 5 [default = false];
  bool has_force_backward() const;
  private:
  bool _internal_has_force_backward() const;
  public:
  void clear_force_backward();
  bool force_backward() const;
  void set_force_backward(bool value);
  private:
  bool _internal_force_backward() const;
  void _internal_set_force_backward(bool value);
  public:

  // optional bool debug_info = 7 [default = false];
  bool has_debug_info() const;
  private:
  bool _internal_has_debug_info() const;
  public:
  void clear_debug_info();
  bool debug_info() const;
  void set_debug_info(bool value);
  private:
  bool _internal_debug_info() const;
  void _internal_set_debug_info(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.NetParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter > layers_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > input_dim_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape > input_shape_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::LayerParameter > layer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::opencv_caffe::NetState* state_;
    bool force_backward_;
    bool debug_info_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SolverParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SolverParameter) */ {
 public:
  inline SolverParameter() : SolverParameter(nullptr) {}
  ~SolverParameter() override;
  explicit PROTOBUF_CONSTEXPR SolverParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SolverParameter& operator=(const SolverParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolverParameter& operator=(SolverParameter&& 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 SolverParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const SolverParameter* internal_default_instance() {
    return reinterpret_cast<const SolverParameter*>(
               &_SolverParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(SolverParameter& a, SolverParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(SolverParameter* 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(SolverParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SolverParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SolverParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SolverParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SolverParameter& from) {
    SolverParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SolverParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SolverParameter";
  }
  protected:
  explicit SolverParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 SolverParameter_SnapshotFormat SnapshotFormat;
  static constexpr SnapshotFormat HDF5 =
    SolverParameter_SnapshotFormat_HDF5;
  static constexpr SnapshotFormat BINARYPROTO =
    SolverParameter_SnapshotFormat_BINARYPROTO;
  static inline bool SnapshotFormat_IsValid(int value) {
    return SolverParameter_SnapshotFormat_IsValid(value);
  }
  static constexpr SnapshotFormat SnapshotFormat_MIN =
    SolverParameter_SnapshotFormat_SnapshotFormat_MIN;
  static constexpr SnapshotFormat SnapshotFormat_MAX =
    SolverParameter_SnapshotFormat_SnapshotFormat_MAX;
  static constexpr int SnapshotFormat_ARRAYSIZE =
    SolverParameter_SnapshotFormat_SnapshotFormat_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SnapshotFormat_descriptor() {
    return SolverParameter_SnapshotFormat_descriptor();
  }
  template<typename T>
  static inline const std::string& SnapshotFormat_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SnapshotFormat>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SnapshotFormat_Name.");
    return SolverParameter_SnapshotFormat_Name(enum_t_value);
  }
  static inline bool SnapshotFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SnapshotFormat* value) {
    return SolverParameter_SnapshotFormat_Parse(name, value);
  }

  typedef SolverParameter_SolverMode SolverMode;
  static constexpr SolverMode CPU =
    SolverParameter_SolverMode_CPU;
  static constexpr SolverMode GPU =
    SolverParameter_SolverMode_GPU;
  static inline bool SolverMode_IsValid(int value) {
    return SolverParameter_SolverMode_IsValid(value);
  }
  static constexpr SolverMode SolverMode_MIN =
    SolverParameter_SolverMode_SolverMode_MIN;
  static constexpr SolverMode SolverMode_MAX =
    SolverParameter_SolverMode_SolverMode_MAX;
  static constexpr int SolverMode_ARRAYSIZE =
    SolverParameter_SolverMode_SolverMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SolverMode_descriptor() {
    return SolverParameter_SolverMode_descriptor();
  }
  template<typename T>
  static inline const std::string& SolverMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SolverMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SolverMode_Name.");
    return SolverParameter_SolverMode_Name(enum_t_value);
  }
  static inline bool SolverMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SolverMode* value) {
    return SolverParameter_SolverMode_Parse(name, value);
  }

  typedef SolverParameter_SolverType SolverType;
  static constexpr SolverType SGD =
    SolverParameter_SolverType_SGD;
  static constexpr SolverType NESTEROV =
    SolverParameter_SolverType_NESTEROV;
  static constexpr SolverType ADAGRAD =
    SolverParameter_SolverType_ADAGRAD;
  static constexpr SolverType RMSPROP =
    SolverParameter_SolverType_RMSPROP;
  static constexpr SolverType ADADELTA =
    SolverParameter_SolverType_ADADELTA;
  static constexpr SolverType ADAM =
    SolverParameter_SolverType_ADAM;
  static inline bool SolverType_IsValid(int value) {
    return SolverParameter_SolverType_IsValid(value);
  }
  static constexpr SolverType SolverType_MIN =
    SolverParameter_SolverType_SolverType_MIN;
  static constexpr SolverType SolverType_MAX =
    SolverParameter_SolverType_SolverType_MAX;
  static constexpr int SolverType_ARRAYSIZE =
    SolverParameter_SolverType_SolverType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SolverType_descriptor() {
    return SolverParameter_SolverType_descriptor();
  }
  template<typename T>
  static inline const std::string& SolverType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SolverType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SolverType_Name.");
    return SolverParameter_SolverType_Name(enum_t_value);
  }
  static inline bool SolverType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SolverType* value) {
    return SolverParameter_SolverType_Parse(name, value);
  }

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

  enum : int {
    kTestNetFieldNumber = 2,
    kTestIterFieldNumber = 3,
    kTestNetParamFieldNumber = 22,
    kTestStateFieldNumber = 27,
    kStepvalueFieldNumber = 34,
    kTrainNetFieldNumber = 1,
    kLrPolicyFieldNumber = 8,
    kSnapshotPrefixFieldNumber = 15,
    kNetFieldNumber = 24,
    kRegularizationTypeFieldNumber = 29,
    kTypeFieldNumber = 40,
    kTrainNetParamFieldNumber = 21,
    kNetParamFieldNumber = 25,
    kTrainStateFieldNumber = 26,
    kTestIntervalFieldNumber = 4,
    kBaseLrFieldNumber = 5,
    kDisplayFieldNumber = 6,
    kMaxIterFieldNumber = 7,
    kGammaFieldNumber = 9,
    kPowerFieldNumber = 10,
    kMomentumFieldNumber = 11,
    kWeightDecayFieldNumber = 12,
    kStepsizeFieldNumber = 13,
    kSnapshotFieldNumber = 14,
    kDeviceIdFieldNumber = 18,
    kTestComputeLossFieldNumber = 19,
    kSnapshotDiffFieldNumber = 16,
    kDebugInfoFieldNumber = 23,
    kSolverTypeFieldNumber = 30,
    kMomentum2FieldNumber = 39,
    kRandomSeedFieldNumber = 20,
    kSolverModeFieldNumber = 17,
    kTestInitializationFieldNumber = 32,
    kSnapshotAfterTrainFieldNumber = 28,
    kDeltaFieldNumber = 31,
    kAverageLossFieldNumber = 33,
    kClipGradientsFieldNumber = 35,
    kIterSizeFieldNumber = 36,
    kSnapshotFormatFieldNumber = 37,
    kRmsDecayFieldNumber = 38,
  };
  // repeated string test_net = 2;
  int test_net_size() const;
  private:
  int _internal_test_net_size() const;
  public:
  void clear_test_net();
  const std::string& test_net(int index) const;
  std::string* mutable_test_net(int index);
  void set_test_net(int index, const std::string& value);
  void set_test_net(int index, std::string&& value);
  void set_test_net(int index, const char* value);
  void set_test_net(int index, const char* value, size_t size);
  std::string* add_test_net();
  void add_test_net(const std::string& value);
  void add_test_net(std::string&& value);
  void add_test_net(const char* value);
  void add_test_net(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& test_net() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_test_net();
  private:
  const std::string& _internal_test_net(int index) const;
  std::string* _internal_add_test_net();
  public:

  // repeated int32 test_iter = 3;
  int test_iter_size() const;
  private:
  int _internal_test_iter_size() const;
  public:
  void clear_test_iter();
  private:
  int32_t _internal_test_iter(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_test_iter() const;
  void _internal_add_test_iter(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_test_iter();
  public:
  int32_t test_iter(int index) const;
  void set_test_iter(int index, int32_t value);
  void add_test_iter(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      test_iter() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_test_iter();

  // repeated .opencv_caffe.NetParameter test_net_param = 22;
  int test_net_param_size() const;
  private:
  int _internal_test_net_param_size() const;
  public:
  void clear_test_net_param();
  ::opencv_caffe::NetParameter* mutable_test_net_param(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter >*
      mutable_test_net_param();
  private:
  const ::opencv_caffe::NetParameter& _internal_test_net_param(int index) const;
  ::opencv_caffe::NetParameter* _internal_add_test_net_param();
  public:
  const ::opencv_caffe::NetParameter& test_net_param(int index) const;
  ::opencv_caffe::NetParameter* add_test_net_param();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter >&
      test_net_param() const;

  // repeated .opencv_caffe.NetState test_state = 27;
  int test_state_size() const;
  private:
  int _internal_test_state_size() const;
  public:
  void clear_test_state();
  ::opencv_caffe::NetState* mutable_test_state(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >*
      mutable_test_state();
  private:
  const ::opencv_caffe::NetState& _internal_test_state(int index) const;
  ::opencv_caffe::NetState* _internal_add_test_state();
  public:
  const ::opencv_caffe::NetState& test_state(int index) const;
  ::opencv_caffe::NetState* add_test_state();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >&
      test_state() const;

  // repeated int32 stepvalue = 34;
  int stepvalue_size() const;
  private:
  int _internal_stepvalue_size() const;
  public:
  void clear_stepvalue();
  private:
  int32_t _internal_stepvalue(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_stepvalue() const;
  void _internal_add_stepvalue(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_stepvalue();
  public:
  int32_t stepvalue(int index) const;
  void set_stepvalue(int index, int32_t value);
  void add_stepvalue(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      stepvalue() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_stepvalue();

  // optional string train_net = 1;
  bool has_train_net() const;
  private:
  bool _internal_has_train_net() const;
  public:
  void clear_train_net();
  const std::string& train_net() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_train_net(ArgT0&& arg0, ArgT... args);
  std::string* mutable_train_net();
  PROTOBUF_NODISCARD std::string* release_train_net();
  void set_allocated_train_net(std::string* train_net);
  private:
  const std::string& _internal_train_net() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_train_net(const std::string& value);
  std::string* _internal_mutable_train_net();
  public:

  // optional string lr_policy = 8;
  bool has_lr_policy() const;
  private:
  bool _internal_has_lr_policy() const;
  public:
  void clear_lr_policy();
  const std::string& lr_policy() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lr_policy(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lr_policy();
  PROTOBUF_NODISCARD std::string* release_lr_policy();
  void set_allocated_lr_policy(std::string* lr_policy);
  private:
  const std::string& _internal_lr_policy() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lr_policy(const std::string& value);
  std::string* _internal_mutable_lr_policy();
  public:

  // optional string snapshot_prefix = 15;
  bool has_snapshot_prefix() const;
  private:
  bool _internal_has_snapshot_prefix() const;
  public:
  void clear_snapshot_prefix();
  const std::string& snapshot_prefix() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_snapshot_prefix(ArgT0&& arg0, ArgT... args);
  std::string* mutable_snapshot_prefix();
  PROTOBUF_NODISCARD std::string* release_snapshot_prefix();
  void set_allocated_snapshot_prefix(std::string* snapshot_prefix);
  private:
  const std::string& _internal_snapshot_prefix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_prefix(const std::string& value);
  std::string* _internal_mutable_snapshot_prefix();
  public:

  // optional string net = 24;
  bool has_net() const;
  private:
  bool _internal_has_net() const;
  public:
  void clear_net();
  const std::string& net() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_net(ArgT0&& arg0, ArgT... args);
  std::string* mutable_net();
  PROTOBUF_NODISCARD std::string* release_net();
  void set_allocated_net(std::string* net);
  private:
  const std::string& _internal_net() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_net(const std::string& value);
  std::string* _internal_mutable_net();
  public:

  // optional string regularization_type = 29 [default = "L2"];
  bool has_regularization_type() const;
  private:
  bool _internal_has_regularization_type() const;
  public:
  void clear_regularization_type();
  const std::string& regularization_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_regularization_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_regularization_type();
  PROTOBUF_NODISCARD std::string* release_regularization_type();
  void set_allocated_regularization_type(std::string* regularization_type);
  private:
  const std::string& _internal_regularization_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_regularization_type(const std::string& value);
  std::string* _internal_mutable_regularization_type();
  public:

  // optional string type = 40 [default = "SGD"];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // optional .opencv_caffe.NetParameter train_net_param = 21;
  bool has_train_net_param() const;
  private:
  bool _internal_has_train_net_param() const;
  public:
  void clear_train_net_param();
  const ::opencv_caffe::NetParameter& train_net_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::NetParameter* release_train_net_param();
  ::opencv_caffe::NetParameter* mutable_train_net_param();
  void set_allocated_train_net_param(::opencv_caffe::NetParameter* train_net_param);
  private:
  const ::opencv_caffe::NetParameter& _internal_train_net_param() const;
  ::opencv_caffe::NetParameter* _internal_mutable_train_net_param();
  public:
  void unsafe_arena_set_allocated_train_net_param(
      ::opencv_caffe::NetParameter* train_net_param);
  ::opencv_caffe::NetParameter* unsafe_arena_release_train_net_param();

  // optional .opencv_caffe.NetParameter net_param = 25;
  bool has_net_param() const;
  private:
  bool _internal_has_net_param() const;
  public:
  void clear_net_param();
  const ::opencv_caffe::NetParameter& net_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::NetParameter* release_net_param();
  ::opencv_caffe::NetParameter* mutable_net_param();
  void set_allocated_net_param(::opencv_caffe::NetParameter* net_param);
  private:
  const ::opencv_caffe::NetParameter& _internal_net_param() const;
  ::opencv_caffe::NetParameter* _internal_mutable_net_param();
  public:
  void unsafe_arena_set_allocated_net_param(
      ::opencv_caffe::NetParameter* net_param);
  ::opencv_caffe::NetParameter* unsafe_arena_release_net_param();

  // optional .opencv_caffe.NetState train_state = 26;
  bool has_train_state() const;
  private:
  bool _internal_has_train_state() const;
  public:
  void clear_train_state();
  const ::opencv_caffe::NetState& train_state() const;
  PROTOBUF_NODISCARD ::opencv_caffe::NetState* release_train_state();
  ::opencv_caffe::NetState* mutable_train_state();
  void set_allocated_train_state(::opencv_caffe::NetState* train_state);
  private:
  const ::opencv_caffe::NetState& _internal_train_state() const;
  ::opencv_caffe::NetState* _internal_mutable_train_state();
  public:
  void unsafe_arena_set_allocated_train_state(
      ::opencv_caffe::NetState* train_state);
  ::opencv_caffe::NetState* unsafe_arena_release_train_state();

  // optional int32 test_interval = 4 [default = 0];
  bool has_test_interval() const;
  private:
  bool _internal_has_test_interval() const;
  public:
  void clear_test_interval();
  int32_t test_interval() const;
  void set_test_interval(int32_t value);
  private:
  int32_t _internal_test_interval() const;
  void _internal_set_test_interval(int32_t value);
  public:

  // optional float base_lr = 5;
  bool has_base_lr() const;
  private:
  bool _internal_has_base_lr() const;
  public:
  void clear_base_lr();
  float base_lr() const;
  void set_base_lr(float value);
  private:
  float _internal_base_lr() const;
  void _internal_set_base_lr(float value);
  public:

  // optional int32 display = 6;
  bool has_display() const;
  private:
  bool _internal_has_display() const;
  public:
  void clear_display();
  int32_t display() const;
  void set_display(int32_t value);
  private:
  int32_t _internal_display() const;
  void _internal_set_display(int32_t value);
  public:

  // optional int32 max_iter = 7;
  bool has_max_iter() const;
  private:
  bool _internal_has_max_iter() const;
  public:
  void clear_max_iter();
  int32_t max_iter() const;
  void set_max_iter(int32_t value);
  private:
  int32_t _internal_max_iter() const;
  void _internal_set_max_iter(int32_t value);
  public:

  // optional float gamma = 9;
  bool has_gamma() const;
  private:
  bool _internal_has_gamma() const;
  public:
  void clear_gamma();
  float gamma() const;
  void set_gamma(float value);
  private:
  float _internal_gamma() const;
  void _internal_set_gamma(float value);
  public:

  // optional float power = 10;
  bool has_power() const;
  private:
  bool _internal_has_power() const;
  public:
  void clear_power();
  float power() const;
  void set_power(float value);
  private:
  float _internal_power() const;
  void _internal_set_power(float value);
  public:

  // optional float momentum = 11;
  bool has_momentum() const;
  private:
  bool _internal_has_momentum() const;
  public:
  void clear_momentum();
  float momentum() const;
  void set_momentum(float value);
  private:
  float _internal_momentum() const;
  void _internal_set_momentum(float value);
  public:

  // optional float weight_decay = 12;
  bool has_weight_decay() const;
  private:
  bool _internal_has_weight_decay() const;
  public:
  void clear_weight_decay();
  float weight_decay() const;
  void set_weight_decay(float value);
  private:
  float _internal_weight_decay() const;
  void _internal_set_weight_decay(float value);
  public:

  // optional int32 stepsize = 13;
  bool has_stepsize() const;
  private:
  bool _internal_has_stepsize() const;
  public:
  void clear_stepsize();
  int32_t stepsize() const;
  void set_stepsize(int32_t value);
  private:
  int32_t _internal_stepsize() const;
  void _internal_set_stepsize(int32_t value);
  public:

  // optional int32 snapshot = 14 [default = 0];
  bool has_snapshot() const;
  private:
  bool _internal_has_snapshot() const;
  public:
  void clear_snapshot();
  int32_t snapshot() const;
  void set_snapshot(int32_t value);
  private:
  int32_t _internal_snapshot() const;
  void _internal_set_snapshot(int32_t value);
  public:

  // optional int32 device_id = 18 [default = 0];
  bool has_device_id() const;
  private:
  bool _internal_has_device_id() const;
  public:
  void clear_device_id();
  int32_t device_id() const;
  void set_device_id(int32_t value);
  private:
  int32_t _internal_device_id() const;
  void _internal_set_device_id(int32_t value);
  public:

  // optional bool test_compute_loss = 19 [default = false];
  bool has_test_compute_loss() const;
  private:
  bool _internal_has_test_compute_loss() const;
  public:
  void clear_test_compute_loss();
  bool test_compute_loss() const;
  void set_test_compute_loss(bool value);
  private:
  bool _internal_test_compute_loss() const;
  void _internal_set_test_compute_loss(bool value);
  public:

  // optional bool snapshot_diff = 16 [default = false];
  bool has_snapshot_diff() const;
  private:
  bool _internal_has_snapshot_diff() const;
  public:
  void clear_snapshot_diff();
  bool snapshot_diff() const;
  void set_snapshot_diff(bool value);
  private:
  bool _internal_snapshot_diff() const;
  void _internal_set_snapshot_diff(bool value);
  public:

  // optional bool debug_info = 23 [default = false];
  bool has_debug_info() const;
  private:
  bool _internal_has_debug_info() const;
  public:
  void clear_debug_info();
  bool debug_info() const;
  void set_debug_info(bool value);
  private:
  bool _internal_debug_info() const;
  void _internal_set_debug_info(bool value);
  public:

  // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
  bool has_solver_type() const;
  private:
  bool _internal_has_solver_type() const;
  public:
  void clear_solver_type();
  ::opencv_caffe::SolverParameter_SolverType solver_type() const;
  void set_solver_type(::opencv_caffe::SolverParameter_SolverType value);
  private:
  ::opencv_caffe::SolverParameter_SolverType _internal_solver_type() const;
  void _internal_set_solver_type(::opencv_caffe::SolverParameter_SolverType value);
  public:

  // optional float momentum2 = 39 [default = 0.999];
  bool has_momentum2() const;
  private:
  bool _internal_has_momentum2() const;
  public:
  void clear_momentum2();
  float momentum2() const;
  void set_momentum2(float value);
  private:
  float _internal_momentum2() const;
  void _internal_set_momentum2(float value);
  public:

  // optional int64 random_seed = 20 [default = -1];
  bool has_random_seed() const;
  private:
  bool _internal_has_random_seed() const;
  public:
  void clear_random_seed();
  int64_t random_seed() const;
  void set_random_seed(int64_t value);
  private:
  int64_t _internal_random_seed() const;
  void _internal_set_random_seed(int64_t value);
  public:

  // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
  bool has_solver_mode() const;
  private:
  bool _internal_has_solver_mode() const;
  public:
  void clear_solver_mode();
  ::opencv_caffe::SolverParameter_SolverMode solver_mode() const;
  void set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value);
  private:
  ::opencv_caffe::SolverParameter_SolverMode _internal_solver_mode() const;
  void _internal_set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value);
  public:

  // optional bool test_initialization = 32 [default = true];
  bool has_test_initialization() const;
  private:
  bool _internal_has_test_initialization() const;
  public:
  void clear_test_initialization();
  bool test_initialization() const;
  void set_test_initialization(bool value);
  private:
  bool _internal_test_initialization() const;
  void _internal_set_test_initialization(bool value);
  public:

  // optional bool snapshot_after_train = 28 [default = true];
  bool has_snapshot_after_train() const;
  private:
  bool _internal_has_snapshot_after_train() const;
  public:
  void clear_snapshot_after_train();
  bool snapshot_after_train() const;
  void set_snapshot_after_train(bool value);
  private:
  bool _internal_snapshot_after_train() const;
  void _internal_set_snapshot_after_train(bool value);
  public:

  // optional float delta = 31 [default = 1e-08];
  bool has_delta() const;
  private:
  bool _internal_has_delta() const;
  public:
  void clear_delta();
  float delta() const;
  void set_delta(float value);
  private:
  float _internal_delta() const;
  void _internal_set_delta(float value);
  public:

  // optional int32 average_loss = 33 [default = 1];
  bool has_average_loss() const;
  private:
  bool _internal_has_average_loss() const;
  public:
  void clear_average_loss();
  int32_t average_loss() const;
  void set_average_loss(int32_t value);
  private:
  int32_t _internal_average_loss() const;
  void _internal_set_average_loss(int32_t value);
  public:

  // optional float clip_gradients = 35 [default = -1];
  bool has_clip_gradients() const;
  private:
  bool _internal_has_clip_gradients() const;
  public:
  void clear_clip_gradients();
  float clip_gradients() const;
  void set_clip_gradients(float value);
  private:
  float _internal_clip_gradients() const;
  void _internal_set_clip_gradients(float value);
  public:

  // optional int32 iter_size = 36 [default = 1];
  bool has_iter_size() const;
  private:
  bool _internal_has_iter_size() const;
  public:
  void clear_iter_size();
  int32_t iter_size() const;
  void set_iter_size(int32_t value);
  private:
  int32_t _internal_iter_size() const;
  void _internal_set_iter_size(int32_t value);
  public:

  // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
  bool has_snapshot_format() const;
  private:
  bool _internal_has_snapshot_format() const;
  public:
  void clear_snapshot_format();
  ::opencv_caffe::SolverParameter_SnapshotFormat snapshot_format() const;
  void set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value);
  private:
  ::opencv_caffe::SolverParameter_SnapshotFormat _internal_snapshot_format() const;
  void _internal_set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value);
  public:

  // optional float rms_decay = 38 [default = 0.99];
  bool has_rms_decay() const;
  private:
  bool _internal_has_rms_decay() const;
  public:
  void clear_rms_decay();
  float rms_decay() const;
  void set_rms_decay(float value);
  private:
  float _internal_rms_decay() const;
  void _internal_set_rms_decay(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SolverParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> test_net_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > test_iter_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter > test_net_param_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState > test_state_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > stepvalue_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr train_net_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lr_policy_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshot_prefix_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr net_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_regularization_type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr regularization_type_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
    ::opencv_caffe::NetParameter* train_net_param_;
    ::opencv_caffe::NetParameter* net_param_;
    ::opencv_caffe::NetState* train_state_;
    int32_t test_interval_;
    float base_lr_;
    int32_t display_;
    int32_t max_iter_;
    float gamma_;
    float power_;
    float momentum_;
    float weight_decay_;
    int32_t stepsize_;
    int32_t snapshot_;
    int32_t device_id_;
    bool test_compute_loss_;
    bool snapshot_diff_;
    bool debug_info_;
    int solver_type_;
    float momentum2_;
    int64_t random_seed_;
    int solver_mode_;
    bool test_initialization_;
    bool snapshot_after_train_;
    float delta_;
    int32_t average_loss_;
    float clip_gradients_;
    int32_t iter_size_;
    int snapshot_format_;
    float rms_decay_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SolverState final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SolverState) */ {
 public:
  inline SolverState() : SolverState(nullptr) {}
  ~SolverState() override;
  explicit PROTOBUF_CONSTEXPR SolverState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SolverState& operator=(const SolverState& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolverState& operator=(SolverState&& 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 SolverState& default_instance() {
    return *internal_default_instance();
  }
  static inline const SolverState* internal_default_instance() {
    return reinterpret_cast<const SolverState*>(
               &_SolverState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(SolverState& a, SolverState& b) {
    a.Swap(&b);
  }
  inline void Swap(SolverState* 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(SolverState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SolverState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SolverState>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SolverState& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SolverState& from) {
    SolverState::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SolverState* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SolverState";
  }
  protected:
  explicit SolverState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kHistoryFieldNumber = 3,
    kLearnedNetFieldNumber = 2,
    kIterFieldNumber = 1,
    kCurrentStepFieldNumber = 4,
  };
  // repeated .opencv_caffe.BlobProto history = 3;
  int history_size() const;
  private:
  int _internal_history_size() const;
  public:
  void clear_history();
  ::opencv_caffe::BlobProto* mutable_history(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
      mutable_history();
  private:
  const ::opencv_caffe::BlobProto& _internal_history(int index) const;
  ::opencv_caffe::BlobProto* _internal_add_history();
  public:
  const ::opencv_caffe::BlobProto& history(int index) const;
  ::opencv_caffe::BlobProto* add_history();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
      history() const;

  // optional string learned_net = 2;
  bool has_learned_net() const;
  private:
  bool _internal_has_learned_net() const;
  public:
  void clear_learned_net();
  const std::string& learned_net() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_learned_net(ArgT0&& arg0, ArgT... args);
  std::string* mutable_learned_net();
  PROTOBUF_NODISCARD std::string* release_learned_net();
  void set_allocated_learned_net(std::string* learned_net);
  private:
  const std::string& _internal_learned_net() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_learned_net(const std::string& value);
  std::string* _internal_mutable_learned_net();
  public:

  // optional int32 iter = 1;
  bool has_iter() const;
  private:
  bool _internal_has_iter() const;
  public:
  void clear_iter();
  int32_t iter() const;
  void set_iter(int32_t value);
  private:
  int32_t _internal_iter() const;
  void _internal_set_iter(int32_t value);
  public:

  // optional int32 current_step = 4 [default = 0];
  bool has_current_step() const;
  private:
  bool _internal_has_current_step() const;
  public:
  void clear_current_step();
  int32_t current_step() const;
  void set_current_step(int32_t value);
  private:
  int32_t _internal_current_step() const;
  void _internal_set_current_step(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SolverState)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > history_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr learned_net_;
    int32_t iter_;
    int32_t current_step_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class NetState final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetState) */ {
 public:
  inline NetState() : NetState(nullptr) {}
  ~NetState() override;
  explicit PROTOBUF_CONSTEXPR NetState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline NetState& operator=(const NetState& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetState& operator=(NetState&& 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 NetState& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetState* internal_default_instance() {
    return reinterpret_cast<const NetState*>(
               &_NetState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(NetState& a, NetState& b) {
    a.Swap(&b);
  }
  inline void Swap(NetState* 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(NetState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NetState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetState>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NetState& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NetState& from) {
    NetState::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NetState* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.NetState";
  }
  protected:
  explicit NetState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kStageFieldNumber = 3,
    kLevelFieldNumber = 2,
    kPhaseFieldNumber = 1,
  };
  // repeated string stage = 3;
  int stage_size() const;
  private:
  int _internal_stage_size() const;
  public:
  void clear_stage();
  const std::string& stage(int index) const;
  std::string* mutable_stage(int index);
  void set_stage(int index, const std::string& value);
  void set_stage(int index, std::string&& value);
  void set_stage(int index, const char* value);
  void set_stage(int index, const char* value, size_t size);
  std::string* add_stage();
  void add_stage(const std::string& value);
  void add_stage(std::string&& value);
  void add_stage(const char* value);
  void add_stage(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& stage() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_stage();
  private:
  const std::string& _internal_stage(int index) const;
  std::string* _internal_add_stage();
  public:

  // optional int32 level = 2 [default = 0];
  bool has_level() const;
  private:
  bool _internal_has_level() const;
  public:
  void clear_level();
  int32_t level() const;
  void set_level(int32_t value);
  private:
  int32_t _internal_level() const;
  void _internal_set_level(int32_t value);
  public:

  // optional .opencv_caffe.Phase phase = 1 [default = TEST];
  bool has_phase() const;
  private:
  bool _internal_has_phase() const;
  public:
  void clear_phase();
  ::opencv_caffe::Phase phase() const;
  void set_phase(::opencv_caffe::Phase value);
  private:
  ::opencv_caffe::Phase _internal_phase() const;
  void _internal_set_phase(::opencv_caffe::Phase value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.NetState)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> stage_;
    int32_t level_;
    int phase_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class NetStateRule final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NetStateRule) */ {
 public:
  inline NetStateRule() : NetStateRule(nullptr) {}
  ~NetStateRule() override;
  explicit PROTOBUF_CONSTEXPR NetStateRule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline NetStateRule& operator=(const NetStateRule& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetStateRule& operator=(NetStateRule&& 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 NetStateRule& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetStateRule* internal_default_instance() {
    return reinterpret_cast<const NetStateRule*>(
               &_NetStateRule_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(NetStateRule& a, NetStateRule& b) {
    a.Swap(&b);
  }
  inline void Swap(NetStateRule* 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(NetStateRule* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NetStateRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetStateRule>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NetStateRule& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NetStateRule& from) {
    NetStateRule::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NetStateRule* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.NetStateRule";
  }
  protected:
  explicit NetStateRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kStageFieldNumber = 4,
    kNotStageFieldNumber = 5,
    kPhaseFieldNumber = 1,
    kMinLevelFieldNumber = 2,
    kMaxLevelFieldNumber = 3,
  };
  // repeated string stage = 4;
  int stage_size() const;
  private:
  int _internal_stage_size() const;
  public:
  void clear_stage();
  const std::string& stage(int index) const;
  std::string* mutable_stage(int index);
  void set_stage(int index, const std::string& value);
  void set_stage(int index, std::string&& value);
  void set_stage(int index, const char* value);
  void set_stage(int index, const char* value, size_t size);
  std::string* add_stage();
  void add_stage(const std::string& value);
  void add_stage(std::string&& value);
  void add_stage(const char* value);
  void add_stage(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& stage() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_stage();
  private:
  const std::string& _internal_stage(int index) const;
  std::string* _internal_add_stage();
  public:

  // repeated string not_stage = 5;
  int not_stage_size() const;
  private:
  int _internal_not_stage_size() const;
  public:
  void clear_not_stage();
  const std::string& not_stage(int index) const;
  std::string* mutable_not_stage(int index);
  void set_not_stage(int index, const std::string& value);
  void set_not_stage(int index, std::string&& value);
  void set_not_stage(int index, const char* value);
  void set_not_stage(int index, const char* value, size_t size);
  std::string* add_not_stage();
  void add_not_stage(const std::string& value);
  void add_not_stage(std::string&& value);
  void add_not_stage(const char* value);
  void add_not_stage(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& not_stage() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_not_stage();
  private:
  const std::string& _internal_not_stage(int index) const;
  std::string* _internal_add_not_stage();
  public:

  // optional .opencv_caffe.Phase phase = 1;
  bool has_phase() const;
  private:
  bool _internal_has_phase() const;
  public:
  void clear_phase();
  ::opencv_caffe::Phase phase() const;
  void set_phase(::opencv_caffe::Phase value);
  private:
  ::opencv_caffe::Phase _internal_phase() const;
  void _internal_set_phase(::opencv_caffe::Phase value);
  public:

  // optional int32 min_level = 2;
  bool has_min_level() const;
  private:
  bool _internal_has_min_level() const;
  public:
  void clear_min_level();
  int32_t min_level() const;
  void set_min_level(int32_t value);
  private:
  int32_t _internal_min_level() const;
  void _internal_set_min_level(int32_t value);
  public:

  // optional int32 max_level = 3;
  bool has_max_level() const;
  private:
  bool _internal_has_max_level() const;
  public:
  void clear_max_level();
  int32_t max_level() const;
  void set_max_level(int32_t value);
  private:
  int32_t _internal_max_level() const;
  void _internal_set_max_level(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.NetStateRule)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> stage_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> not_stage_;
    int phase_;
    int32_t min_level_;
    int32_t max_level_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ParamSpec final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ParamSpec) */ {
 public:
  inline ParamSpec() : ParamSpec(nullptr) {}
  ~ParamSpec() override;
  explicit PROTOBUF_CONSTEXPR ParamSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ParamSpec& operator=(const ParamSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ParamSpec& operator=(ParamSpec&& 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 ParamSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ParamSpec* internal_default_instance() {
    return reinterpret_cast<const ParamSpec*>(
               &_ParamSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(ParamSpec& a, ParamSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(ParamSpec* 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(ParamSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ParamSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ParamSpec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ParamSpec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ParamSpec& from) {
    ParamSpec::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ParamSpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ParamSpec";
  }
  protected:
  explicit ParamSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 ParamSpec_DimCheckMode DimCheckMode;
  static constexpr DimCheckMode STRICT =
    ParamSpec_DimCheckMode_STRICT;
  static constexpr DimCheckMode PERMISSIVE =
    ParamSpec_DimCheckMode_PERMISSIVE;
  static inline bool DimCheckMode_IsValid(int value) {
    return ParamSpec_DimCheckMode_IsValid(value);
  }
  static constexpr DimCheckMode DimCheckMode_MIN =
    ParamSpec_DimCheckMode_DimCheckMode_MIN;
  static constexpr DimCheckMode DimCheckMode_MAX =
    ParamSpec_DimCheckMode_DimCheckMode_MAX;
  static constexpr int DimCheckMode_ARRAYSIZE =
    ParamSpec_DimCheckMode_DimCheckMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DimCheckMode_descriptor() {
    return ParamSpec_DimCheckMode_descriptor();
  }
  template<typename T>
  static inline const std::string& DimCheckMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DimCheckMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DimCheckMode_Name.");
    return ParamSpec_DimCheckMode_Name(enum_t_value);
  }
  static inline bool DimCheckMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DimCheckMode* value) {
    return ParamSpec_DimCheckMode_Parse(name, value);
  }

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

  enum : int {
    kNameFieldNumber = 1,
    kShareModeFieldNumber = 2,
    kLrMultFieldNumber = 3,
    kDecayMultFieldNumber = 4,
  };
  // optional 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 .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
  bool has_share_mode() const;
  private:
  bool _internal_has_share_mode() const;
  public:
  void clear_share_mode();
  ::opencv_caffe::ParamSpec_DimCheckMode share_mode() const;
  void set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value);
  private:
  ::opencv_caffe::ParamSpec_DimCheckMode _internal_share_mode() const;
  void _internal_set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value);
  public:

  // optional float lr_mult = 3 [default = 1];
  bool has_lr_mult() const;
  private:
  bool _internal_has_lr_mult() const;
  public:
  void clear_lr_mult();
  float lr_mult() const;
  void set_lr_mult(float value);
  private:
  float _internal_lr_mult() const;
  void _internal_set_lr_mult(float value);
  public:

  // optional float decay_mult = 4 [default = 1];
  bool has_decay_mult() const;
  private:
  bool _internal_has_decay_mult() const;
  public:
  void clear_decay_mult();
  float decay_mult() const;
  void set_decay_mult(float value);
  private:
  float _internal_decay_mult() const;
  void _internal_set_decay_mult(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ParamSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    int share_mode_;
    float lr_mult_;
    float decay_mult_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class LayerParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LayerParameter) */ {
 public:
  inline LayerParameter() : LayerParameter(nullptr) {}
  ~LayerParameter() override;
  explicit PROTOBUF_CONSTEXPR LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LayerParameter& operator=(const LayerParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline LayerParameter& operator=(LayerParameter&& 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 LayerParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const LayerParameter* internal_default_instance() {
    return reinterpret_cast<const LayerParameter*>(
               &_LayerParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(LayerParameter& a, LayerParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(LayerParameter* 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(LayerParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LayerParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LayerParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LayerParameter& from) {
    LayerParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LayerParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.LayerParameter";
  }
  protected:
  explicit LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kBottomFieldNumber = 3,
    kTopFieldNumber = 4,
    kLossWeightFieldNumber = 5,
    kParamFieldNumber = 6,
    kBlobsFieldNumber = 7,
    kIncludeFieldNumber = 8,
    kExcludeFieldNumber = 9,
    kPropagateDownFieldNumber = 11,
    kNameFieldNumber = 1,
    kTypeFieldNumber = 2,
    kTransformParamFieldNumber = 100,
    kLossParamFieldNumber = 101,
    kAccuracyParamFieldNumber = 102,
    kArgmaxParamFieldNumber = 103,
    kConcatParamFieldNumber = 104,
    kContrastiveLossParamFieldNumber = 105,
    kConvolutionParamFieldNumber = 106,
    kDataParamFieldNumber = 107,
    kDropoutParamFieldNumber = 108,
    kDummyDataParamFieldNumber = 109,
    kEltwiseParamFieldNumber = 110,
    kExpParamFieldNumber = 111,
    kHdf5DataParamFieldNumber = 112,
    kHdf5OutputParamFieldNumber = 113,
    kHingeLossParamFieldNumber = 114,
    kImageDataParamFieldNumber = 115,
    kInfogainLossParamFieldNumber = 116,
    kInnerProductParamFieldNumber = 117,
    kLrnParamFieldNumber = 118,
    kMemoryDataParamFieldNumber = 119,
    kMvnParamFieldNumber = 120,
    kPoolingParamFieldNumber = 121,
    kPowerParamFieldNumber = 122,
    kReluParamFieldNumber = 123,
    kSigmoidParamFieldNumber = 124,
    kSoftmaxParamFieldNumber = 125,
    kSliceParamFieldNumber = 126,
    kTanhParamFieldNumber = 127,
    kThresholdParamFieldNumber = 128,
    kWindowDataParamFieldNumber = 129,
    kPythonParamFieldNumber = 130,
    kPreluParamFieldNumber = 131,
    kSppParamFieldNumber = 132,
    kReshapeParamFieldNumber = 133,
    kLogParamFieldNumber = 134,
    kFlattenParamFieldNumber = 135,
    kReductionParamFieldNumber = 136,
    kEmbedParamFieldNumber = 137,
    kTileParamFieldNumber = 138,
    kBatchNormParamFieldNumber = 139,
    kEluParamFieldNumber = 140,
    kBiasParamFieldNumber = 141,
    kScaleParamFieldNumber = 142,
    kInputParamFieldNumber = 143,
    kCropParamFieldNumber = 144,
    kParameterParamFieldNumber = 145,
    kRecurrentParamFieldNumber = 146,
    kDetectionOutputParamFieldNumber = 147,
    kPermuteParamFieldNumber = 148,
    kNormParamFieldNumber = 149,
    kPriorBoxParamFieldNumber = 150,
    kProposalParamFieldNumber = 201,
    kPsroiPoolingParamFieldNumber = 10002,
    kRoiPoolingParamFieldNumber = 8266711,
    kPhaseFieldNumber = 10,
  };
  // repeated string bottom = 3;
  int bottom_size() const;
  private:
  int _internal_bottom_size() const;
  public:
  void clear_bottom();
  const std::string& bottom(int index) const;
  std::string* mutable_bottom(int index);
  void set_bottom(int index, const std::string& value);
  void set_bottom(int index, std::string&& value);
  void set_bottom(int index, const char* value);
  void set_bottom(int index, const char* value, size_t size);
  std::string* add_bottom();
  void add_bottom(const std::string& value);
  void add_bottom(std::string&& value);
  void add_bottom(const char* value);
  void add_bottom(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bottom() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bottom();
  private:
  const std::string& _internal_bottom(int index) const;
  std::string* _internal_add_bottom();
  public:

  // repeated string top = 4;
  int top_size() const;
  private:
  int _internal_top_size() const;
  public:
  void clear_top();
  const std::string& top(int index) const;
  std::string* mutable_top(int index);
  void set_top(int index, const std::string& value);
  void set_top(int index, std::string&& value);
  void set_top(int index, const char* value);
  void set_top(int index, const char* value, size_t size);
  std::string* add_top();
  void add_top(const std::string& value);
  void add_top(std::string&& value);
  void add_top(const char* value);
  void add_top(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& top() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_top();
  private:
  const std::string& _internal_top(int index) const;
  std::string* _internal_add_top();
  public:

  // repeated float loss_weight = 5;
  int loss_weight_size() const;
  private:
  int _internal_loss_weight_size() const;
  public:
  void clear_loss_weight();
  private:
  float _internal_loss_weight(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_loss_weight() const;
  void _internal_add_loss_weight(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_loss_weight();
  public:
  float loss_weight(int index) const;
  void set_loss_weight(int index, float value);
  void add_loss_weight(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      loss_weight() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_loss_weight();

  // repeated .opencv_caffe.ParamSpec param = 6;
  int param_size() const;
  private:
  int _internal_param_size() const;
  public:
  void clear_param();
  ::opencv_caffe::ParamSpec* mutable_param(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >*
      mutable_param();
  private:
  const ::opencv_caffe::ParamSpec& _internal_param(int index) const;
  ::opencv_caffe::ParamSpec* _internal_add_param();
  public:
  const ::opencv_caffe::ParamSpec& param(int index) const;
  ::opencv_caffe::ParamSpec* add_param();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >&
      param() const;

  // repeated .opencv_caffe.BlobProto blobs = 7;
  int blobs_size() const;
  private:
  int _internal_blobs_size() const;
  public:
  void clear_blobs();
  ::opencv_caffe::BlobProto* mutable_blobs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
      mutable_blobs();
  private:
  const ::opencv_caffe::BlobProto& _internal_blobs(int index) const;
  ::opencv_caffe::BlobProto* _internal_add_blobs();
  public:
  const ::opencv_caffe::BlobProto& blobs(int index) const;
  ::opencv_caffe::BlobProto* add_blobs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
      blobs() const;

  // repeated .opencv_caffe.NetStateRule include = 8;
  int include_size() const;
  private:
  int _internal_include_size() const;
  public:
  void clear_include();
  ::opencv_caffe::NetStateRule* mutable_include(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
      mutable_include();
  private:
  const ::opencv_caffe::NetStateRule& _internal_include(int index) const;
  ::opencv_caffe::NetStateRule* _internal_add_include();
  public:
  const ::opencv_caffe::NetStateRule& include(int index) const;
  ::opencv_caffe::NetStateRule* add_include();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
      include() const;

  // repeated .opencv_caffe.NetStateRule exclude = 9;
  int exclude_size() const;
  private:
  int _internal_exclude_size() const;
  public:
  void clear_exclude();
  ::opencv_caffe::NetStateRule* mutable_exclude(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
      mutable_exclude();
  private:
  const ::opencv_caffe::NetStateRule& _internal_exclude(int index) const;
  ::opencv_caffe::NetStateRule* _internal_add_exclude();
  public:
  const ::opencv_caffe::NetStateRule& exclude(int index) const;
  ::opencv_caffe::NetStateRule* add_exclude();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
      exclude() const;

  // repeated bool propagate_down = 11;
  int propagate_down_size() const;
  private:
  int _internal_propagate_down_size() const;
  public:
  void clear_propagate_down();
  private:
  bool _internal_propagate_down(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_propagate_down() const;
  void _internal_add_propagate_down(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_propagate_down();
  public:
  bool propagate_down(int index) const;
  void set_propagate_down(int index, bool value);
  void add_propagate_down(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      propagate_down() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_propagate_down();

  // optional 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 string type = 2;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // optional .opencv_caffe.TransformationParameter transform_param = 100;
  bool has_transform_param() const;
  private:
  bool _internal_has_transform_param() const;
  public:
  void clear_transform_param();
  const ::opencv_caffe::TransformationParameter& transform_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::TransformationParameter* release_transform_param();
  ::opencv_caffe::TransformationParameter* mutable_transform_param();
  void set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param);
  private:
  const ::opencv_caffe::TransformationParameter& _internal_transform_param() const;
  ::opencv_caffe::TransformationParameter* _internal_mutable_transform_param();
  public:
  void unsafe_arena_set_allocated_transform_param(
      ::opencv_caffe::TransformationParameter* transform_param);
  ::opencv_caffe::TransformationParameter* unsafe_arena_release_transform_param();

  // optional .opencv_caffe.LossParameter loss_param = 101;
  bool has_loss_param() const;
  private:
  bool _internal_has_loss_param() const;
  public:
  void clear_loss_param();
  const ::opencv_caffe::LossParameter& loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::LossParameter* release_loss_param();
  ::opencv_caffe::LossParameter* mutable_loss_param();
  void set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param);
  private:
  const ::opencv_caffe::LossParameter& _internal_loss_param() const;
  ::opencv_caffe::LossParameter* _internal_mutable_loss_param();
  public:
  void unsafe_arena_set_allocated_loss_param(
      ::opencv_caffe::LossParameter* loss_param);
  ::opencv_caffe::LossParameter* unsafe_arena_release_loss_param();

  // optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
  bool has_accuracy_param() const;
  private:
  bool _internal_has_accuracy_param() const;
  public:
  void clear_accuracy_param();
  const ::opencv_caffe::AccuracyParameter& accuracy_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::AccuracyParameter* release_accuracy_param();
  ::opencv_caffe::AccuracyParameter* mutable_accuracy_param();
  void set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param);
  private:
  const ::opencv_caffe::AccuracyParameter& _internal_accuracy_param() const;
  ::opencv_caffe::AccuracyParameter* _internal_mutable_accuracy_param();
  public:
  void unsafe_arena_set_allocated_accuracy_param(
      ::opencv_caffe::AccuracyParameter* accuracy_param);
  ::opencv_caffe::AccuracyParameter* unsafe_arena_release_accuracy_param();

  // optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
  bool has_argmax_param() const;
  private:
  bool _internal_has_argmax_param() const;
  public:
  void clear_argmax_param();
  const ::opencv_caffe::ArgMaxParameter& argmax_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ArgMaxParameter* release_argmax_param();
  ::opencv_caffe::ArgMaxParameter* mutable_argmax_param();
  void set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param);
  private:
  const ::opencv_caffe::ArgMaxParameter& _internal_argmax_param() const;
  ::opencv_caffe::ArgMaxParameter* _internal_mutable_argmax_param();
  public:
  void unsafe_arena_set_allocated_argmax_param(
      ::opencv_caffe::ArgMaxParameter* argmax_param);
  ::opencv_caffe::ArgMaxParameter* unsafe_arena_release_argmax_param();

  // optional .opencv_caffe.ConcatParameter concat_param = 104;
  bool has_concat_param() const;
  private:
  bool _internal_has_concat_param() const;
  public:
  void clear_concat_param();
  const ::opencv_caffe::ConcatParameter& concat_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ConcatParameter* release_concat_param();
  ::opencv_caffe::ConcatParameter* mutable_concat_param();
  void set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param);
  private:
  const ::opencv_caffe::ConcatParameter& _internal_concat_param() const;
  ::opencv_caffe::ConcatParameter* _internal_mutable_concat_param();
  public:
  void unsafe_arena_set_allocated_concat_param(
      ::opencv_caffe::ConcatParameter* concat_param);
  ::opencv_caffe::ConcatParameter* unsafe_arena_release_concat_param();

  // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
  bool has_contrastive_loss_param() const;
  private:
  bool _internal_has_contrastive_loss_param() const;
  public:
  void clear_contrastive_loss_param();
  const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ContrastiveLossParameter* release_contrastive_loss_param();
  ::opencv_caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
  void set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param);
  private:
  const ::opencv_caffe::ContrastiveLossParameter& _internal_contrastive_loss_param() const;
  ::opencv_caffe::ContrastiveLossParameter* _internal_mutable_contrastive_loss_param();
  public:
  void unsafe_arena_set_allocated_contrastive_loss_param(
      ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param);
  ::opencv_caffe::ContrastiveLossParameter* unsafe_arena_release_contrastive_loss_param();

  // optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
  bool has_convolution_param() const;
  private:
  bool _internal_has_convolution_param() const;
  public:
  void clear_convolution_param();
  const ::opencv_caffe::ConvolutionParameter& convolution_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ConvolutionParameter* release_convolution_param();
  ::opencv_caffe::ConvolutionParameter* mutable_convolution_param();
  void set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param);
  private:
  const ::opencv_caffe::ConvolutionParameter& _internal_convolution_param() const;
  ::opencv_caffe::ConvolutionParameter* _internal_mutable_convolution_param();
  public:
  void unsafe_arena_set_allocated_convolution_param(
      ::opencv_caffe::ConvolutionParameter* convolution_param);
  ::opencv_caffe::ConvolutionParameter* unsafe_arena_release_convolution_param();

  // optional .opencv_caffe.DataParameter data_param = 107;
  bool has_data_param() const;
  private:
  bool _internal_has_data_param() const;
  public:
  void clear_data_param();
  const ::opencv_caffe::DataParameter& data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DataParameter* release_data_param();
  ::opencv_caffe::DataParameter* mutable_data_param();
  void set_allocated_data_param(::opencv_caffe::DataParameter* data_param);
  private:
  const ::opencv_caffe::DataParameter& _internal_data_param() const;
  ::opencv_caffe::DataParameter* _internal_mutable_data_param();
  public:
  void unsafe_arena_set_allocated_data_param(
      ::opencv_caffe::DataParameter* data_param);
  ::opencv_caffe::DataParameter* unsafe_arena_release_data_param();

  // optional .opencv_caffe.DropoutParameter dropout_param = 108;
  bool has_dropout_param() const;
  private:
  bool _internal_has_dropout_param() const;
  public:
  void clear_dropout_param();
  const ::opencv_caffe::DropoutParameter& dropout_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DropoutParameter* release_dropout_param();
  ::opencv_caffe::DropoutParameter* mutable_dropout_param();
  void set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param);
  private:
  const ::opencv_caffe::DropoutParameter& _internal_dropout_param() const;
  ::opencv_caffe::DropoutParameter* _internal_mutable_dropout_param();
  public:
  void unsafe_arena_set_allocated_dropout_param(
      ::opencv_caffe::DropoutParameter* dropout_param);
  ::opencv_caffe::DropoutParameter* unsafe_arena_release_dropout_param();

  // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
  bool has_dummy_data_param() const;
  private:
  bool _internal_has_dummy_data_param() const;
  public:
  void clear_dummy_data_param();
  const ::opencv_caffe::DummyDataParameter& dummy_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DummyDataParameter* release_dummy_data_param();
  ::opencv_caffe::DummyDataParameter* mutable_dummy_data_param();
  void set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param);
  private:
  const ::opencv_caffe::DummyDataParameter& _internal_dummy_data_param() const;
  ::opencv_caffe::DummyDataParameter* _internal_mutable_dummy_data_param();
  public:
  void unsafe_arena_set_allocated_dummy_data_param(
      ::opencv_caffe::DummyDataParameter* dummy_data_param);
  ::opencv_caffe::DummyDataParameter* unsafe_arena_release_dummy_data_param();

  // optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
  bool has_eltwise_param() const;
  private:
  bool _internal_has_eltwise_param() const;
  public:
  void clear_eltwise_param();
  const ::opencv_caffe::EltwiseParameter& eltwise_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::EltwiseParameter* release_eltwise_param();
  ::opencv_caffe::EltwiseParameter* mutable_eltwise_param();
  void set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param);
  private:
  const ::opencv_caffe::EltwiseParameter& _internal_eltwise_param() const;
  ::opencv_caffe::EltwiseParameter* _internal_mutable_eltwise_param();
  public:
  void unsafe_arena_set_allocated_eltwise_param(
      ::opencv_caffe::EltwiseParameter* eltwise_param);
  ::opencv_caffe::EltwiseParameter* unsafe_arena_release_eltwise_param();

  // optional .opencv_caffe.ExpParameter exp_param = 111;
  bool has_exp_param() const;
  private:
  bool _internal_has_exp_param() const;
  public:
  void clear_exp_param();
  const ::opencv_caffe::ExpParameter& exp_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ExpParameter* release_exp_param();
  ::opencv_caffe::ExpParameter* mutable_exp_param();
  void set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param);
  private:
  const ::opencv_caffe::ExpParameter& _internal_exp_param() const;
  ::opencv_caffe::ExpParameter* _internal_mutable_exp_param();
  public:
  void unsafe_arena_set_allocated_exp_param(
      ::opencv_caffe::ExpParameter* exp_param);
  ::opencv_caffe::ExpParameter* unsafe_arena_release_exp_param();

  // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
  bool has_hdf5_data_param() const;
  private:
  bool _internal_has_hdf5_data_param() const;
  public:
  void clear_hdf5_data_param();
  const ::opencv_caffe::HDF5DataParameter& hdf5_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HDF5DataParameter* release_hdf5_data_param();
  ::opencv_caffe::HDF5DataParameter* mutable_hdf5_data_param();
  void set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param);
  private:
  const ::opencv_caffe::HDF5DataParameter& _internal_hdf5_data_param() const;
  ::opencv_caffe::HDF5DataParameter* _internal_mutable_hdf5_data_param();
  public:
  void unsafe_arena_set_allocated_hdf5_data_param(
      ::opencv_caffe::HDF5DataParameter* hdf5_data_param);
  ::opencv_caffe::HDF5DataParameter* unsafe_arena_release_hdf5_data_param();

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
  bool has_hdf5_output_param() const;
  private:
  bool _internal_has_hdf5_output_param() const;
  public:
  void clear_hdf5_output_param();
  const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HDF5OutputParameter* release_hdf5_output_param();
  ::opencv_caffe::HDF5OutputParameter* mutable_hdf5_output_param();
  void set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
  private:
  const ::opencv_caffe::HDF5OutputParameter& _internal_hdf5_output_param() const;
  ::opencv_caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param();
  public:
  void unsafe_arena_set_allocated_hdf5_output_param(
      ::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
  ::opencv_caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param();

  // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
  bool has_hinge_loss_param() const;
  private:
  bool _internal_has_hinge_loss_param() const;
  public:
  void clear_hinge_loss_param();
  const ::opencv_caffe::HingeLossParameter& hinge_loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HingeLossParameter* release_hinge_loss_param();
  ::opencv_caffe::HingeLossParameter* mutable_hinge_loss_param();
  void set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param);
  private:
  const ::opencv_caffe::HingeLossParameter& _internal_hinge_loss_param() const;
  ::opencv_caffe::HingeLossParameter* _internal_mutable_hinge_loss_param();
  public:
  void unsafe_arena_set_allocated_hinge_loss_param(
      ::opencv_caffe::HingeLossParameter* hinge_loss_param);
  ::opencv_caffe::HingeLossParameter* unsafe_arena_release_hinge_loss_param();

  // optional .opencv_caffe.ImageDataParameter image_data_param = 115;
  bool has_image_data_param() const;
  private:
  bool _internal_has_image_data_param() const;
  public:
  void clear_image_data_param();
  const ::opencv_caffe::ImageDataParameter& image_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ImageDataParameter* release_image_data_param();
  ::opencv_caffe::ImageDataParameter* mutable_image_data_param();
  void set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param);
  private:
  const ::opencv_caffe::ImageDataParameter& _internal_image_data_param() const;
  ::opencv_caffe::ImageDataParameter* _internal_mutable_image_data_param();
  public:
  void unsafe_arena_set_allocated_image_data_param(
      ::opencv_caffe::ImageDataParameter* image_data_param);
  ::opencv_caffe::ImageDataParameter* unsafe_arena_release_image_data_param();

  // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
  bool has_infogain_loss_param() const;
  private:
  bool _internal_has_infogain_loss_param() const;
  public:
  void clear_infogain_loss_param();
  const ::opencv_caffe::InfogainLossParameter& infogain_loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::InfogainLossParameter* release_infogain_loss_param();
  ::opencv_caffe::InfogainLossParameter* mutable_infogain_loss_param();
  void set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param);
  private:
  const ::opencv_caffe::InfogainLossParameter& _internal_infogain_loss_param() const;
  ::opencv_caffe::InfogainLossParameter* _internal_mutable_infogain_loss_param();
  public:
  void unsafe_arena_set_allocated_infogain_loss_param(
      ::opencv_caffe::InfogainLossParameter* infogain_loss_param);
  ::opencv_caffe::InfogainLossParameter* unsafe_arena_release_infogain_loss_param();

  // optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
  bool has_inner_product_param() const;
  private:
  bool _internal_has_inner_product_param() const;
  public:
  void clear_inner_product_param();
  const ::opencv_caffe::InnerProductParameter& inner_product_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::InnerProductParameter* release_inner_product_param();
  ::opencv_caffe::InnerProductParameter* mutable_inner_product_param();
  void set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param);
  private:
  const ::opencv_caffe::InnerProductParameter& _internal_inner_product_param() const;
  ::opencv_caffe::InnerProductParameter* _internal_mutable_inner_product_param();
  public:
  void unsafe_arena_set_allocated_inner_product_param(
      ::opencv_caffe::InnerProductParameter* inner_product_param);
  ::opencv_caffe::InnerProductParameter* unsafe_arena_release_inner_product_param();

  // optional .opencv_caffe.LRNParameter lrn_param = 118;
  bool has_lrn_param() const;
  private:
  bool _internal_has_lrn_param() const;
  public:
  void clear_lrn_param();
  const ::opencv_caffe::LRNParameter& lrn_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::LRNParameter* release_lrn_param();
  ::opencv_caffe::LRNParameter* mutable_lrn_param();
  void set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param);
  private:
  const ::opencv_caffe::LRNParameter& _internal_lrn_param() const;
  ::opencv_caffe::LRNParameter* _internal_mutable_lrn_param();
  public:
  void unsafe_arena_set_allocated_lrn_param(
      ::opencv_caffe::LRNParameter* lrn_param);
  ::opencv_caffe::LRNParameter* unsafe_arena_release_lrn_param();

  // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
  bool has_memory_data_param() const;
  private:
  bool _internal_has_memory_data_param() const;
  public:
  void clear_memory_data_param();
  const ::opencv_caffe::MemoryDataParameter& memory_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::MemoryDataParameter* release_memory_data_param();
  ::opencv_caffe::MemoryDataParameter* mutable_memory_data_param();
  void set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param);
  private:
  const ::opencv_caffe::MemoryDataParameter& _internal_memory_data_param() const;
  ::opencv_caffe::MemoryDataParameter* _internal_mutable_memory_data_param();
  public:
  void unsafe_arena_set_allocated_memory_data_param(
      ::opencv_caffe::MemoryDataParameter* memory_data_param);
  ::opencv_caffe::MemoryDataParameter* unsafe_arena_release_memory_data_param();

  // optional .opencv_caffe.MVNParameter mvn_param = 120;
  bool has_mvn_param() const;
  private:
  bool _internal_has_mvn_param() const;
  public:
  void clear_mvn_param();
  const ::opencv_caffe::MVNParameter& mvn_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::MVNParameter* release_mvn_param();
  ::opencv_caffe::MVNParameter* mutable_mvn_param();
  void set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param);
  private:
  const ::opencv_caffe::MVNParameter& _internal_mvn_param() const;
  ::opencv_caffe::MVNParameter* _internal_mutable_mvn_param();
  public:
  void unsafe_arena_set_allocated_mvn_param(
      ::opencv_caffe::MVNParameter* mvn_param);
  ::opencv_caffe::MVNParameter* unsafe_arena_release_mvn_param();

  // optional .opencv_caffe.PoolingParameter pooling_param = 121;
  bool has_pooling_param() const;
  private:
  bool _internal_has_pooling_param() const;
  public:
  void clear_pooling_param();
  const ::opencv_caffe::PoolingParameter& pooling_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PoolingParameter* release_pooling_param();
  ::opencv_caffe::PoolingParameter* mutable_pooling_param();
  void set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param);
  private:
  const ::opencv_caffe::PoolingParameter& _internal_pooling_param() const;
  ::opencv_caffe::PoolingParameter* _internal_mutable_pooling_param();
  public:
  void unsafe_arena_set_allocated_pooling_param(
      ::opencv_caffe::PoolingParameter* pooling_param);
  ::opencv_caffe::PoolingParameter* unsafe_arena_release_pooling_param();

  // optional .opencv_caffe.PowerParameter power_param = 122;
  bool has_power_param() const;
  private:
  bool _internal_has_power_param() const;
  public:
  void clear_power_param();
  const ::opencv_caffe::PowerParameter& power_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PowerParameter* release_power_param();
  ::opencv_caffe::PowerParameter* mutable_power_param();
  void set_allocated_power_param(::opencv_caffe::PowerParameter* power_param);
  private:
  const ::opencv_caffe::PowerParameter& _internal_power_param() const;
  ::opencv_caffe::PowerParameter* _internal_mutable_power_param();
  public:
  void unsafe_arena_set_allocated_power_param(
      ::opencv_caffe::PowerParameter* power_param);
  ::opencv_caffe::PowerParameter* unsafe_arena_release_power_param();

  // optional .opencv_caffe.ReLUParameter relu_param = 123;
  bool has_relu_param() const;
  private:
  bool _internal_has_relu_param() const;
  public:
  void clear_relu_param();
  const ::opencv_caffe::ReLUParameter& relu_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ReLUParameter* release_relu_param();
  ::opencv_caffe::ReLUParameter* mutable_relu_param();
  void set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param);
  private:
  const ::opencv_caffe::ReLUParameter& _internal_relu_param() const;
  ::opencv_caffe::ReLUParameter* _internal_mutable_relu_param();
  public:
  void unsafe_arena_set_allocated_relu_param(
      ::opencv_caffe::ReLUParameter* relu_param);
  ::opencv_caffe::ReLUParameter* unsafe_arena_release_relu_param();

  // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
  bool has_sigmoid_param() const;
  private:
  bool _internal_has_sigmoid_param() const;
  public:
  void clear_sigmoid_param();
  const ::opencv_caffe::SigmoidParameter& sigmoid_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SigmoidParameter* release_sigmoid_param();
  ::opencv_caffe::SigmoidParameter* mutable_sigmoid_param();
  void set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param);
  private:
  const ::opencv_caffe::SigmoidParameter& _internal_sigmoid_param() const;
  ::opencv_caffe::SigmoidParameter* _internal_mutable_sigmoid_param();
  public:
  void unsafe_arena_set_allocated_sigmoid_param(
      ::opencv_caffe::SigmoidParameter* sigmoid_param);
  ::opencv_caffe::SigmoidParameter* unsafe_arena_release_sigmoid_param();

  // optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
  bool has_softmax_param() const;
  private:
  bool _internal_has_softmax_param() const;
  public:
  void clear_softmax_param();
  const ::opencv_caffe::SoftmaxParameter& softmax_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SoftmaxParameter* release_softmax_param();
  ::opencv_caffe::SoftmaxParameter* mutable_softmax_param();
  void set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param);
  private:
  const ::opencv_caffe::SoftmaxParameter& _internal_softmax_param() const;
  ::opencv_caffe::SoftmaxParameter* _internal_mutable_softmax_param();
  public:
  void unsafe_arena_set_allocated_softmax_param(
      ::opencv_caffe::SoftmaxParameter* softmax_param);
  ::opencv_caffe::SoftmaxParameter* unsafe_arena_release_softmax_param();

  // optional .opencv_caffe.SliceParameter slice_param = 126;
  bool has_slice_param() const;
  private:
  bool _internal_has_slice_param() const;
  public:
  void clear_slice_param();
  const ::opencv_caffe::SliceParameter& slice_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SliceParameter* release_slice_param();
  ::opencv_caffe::SliceParameter* mutable_slice_param();
  void set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param);
  private:
  const ::opencv_caffe::SliceParameter& _internal_slice_param() const;
  ::opencv_caffe::SliceParameter* _internal_mutable_slice_param();
  public:
  void unsafe_arena_set_allocated_slice_param(
      ::opencv_caffe::SliceParameter* slice_param);
  ::opencv_caffe::SliceParameter* unsafe_arena_release_slice_param();

  // optional .opencv_caffe.TanHParameter tanh_param = 127;
  bool has_tanh_param() const;
  private:
  bool _internal_has_tanh_param() const;
  public:
  void clear_tanh_param();
  const ::opencv_caffe::TanHParameter& tanh_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::TanHParameter* release_tanh_param();
  ::opencv_caffe::TanHParameter* mutable_tanh_param();
  void set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param);
  private:
  const ::opencv_caffe::TanHParameter& _internal_tanh_param() const;
  ::opencv_caffe::TanHParameter* _internal_mutable_tanh_param();
  public:
  void unsafe_arena_set_allocated_tanh_param(
      ::opencv_caffe::TanHParameter* tanh_param);
  ::opencv_caffe::TanHParameter* unsafe_arena_release_tanh_param();

  // optional .opencv_caffe.ThresholdParameter threshold_param = 128;
  bool has_threshold_param() const;
  private:
  bool _internal_has_threshold_param() const;
  public:
  void clear_threshold_param();
  const ::opencv_caffe::ThresholdParameter& threshold_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ThresholdParameter* release_threshold_param();
  ::opencv_caffe::ThresholdParameter* mutable_threshold_param();
  void set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param);
  private:
  const ::opencv_caffe::ThresholdParameter& _internal_threshold_param() const;
  ::opencv_caffe::ThresholdParameter* _internal_mutable_threshold_param();
  public:
  void unsafe_arena_set_allocated_threshold_param(
      ::opencv_caffe::ThresholdParameter* threshold_param);
  ::opencv_caffe::ThresholdParameter* unsafe_arena_release_threshold_param();

  // optional .opencv_caffe.WindowDataParameter window_data_param = 129;
  bool has_window_data_param() const;
  private:
  bool _internal_has_window_data_param() const;
  public:
  void clear_window_data_param();
  const ::opencv_caffe::WindowDataParameter& window_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::WindowDataParameter* release_window_data_param();
  ::opencv_caffe::WindowDataParameter* mutable_window_data_param();
  void set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param);
  private:
  const ::opencv_caffe::WindowDataParameter& _internal_window_data_param() const;
  ::opencv_caffe::WindowDataParameter* _internal_mutable_window_data_param();
  public:
  void unsafe_arena_set_allocated_window_data_param(
      ::opencv_caffe::WindowDataParameter* window_data_param);
  ::opencv_caffe::WindowDataParameter* unsafe_arena_release_window_data_param();

  // optional .opencv_caffe.PythonParameter python_param = 130;
  bool has_python_param() const;
  private:
  bool _internal_has_python_param() const;
  public:
  void clear_python_param();
  const ::opencv_caffe::PythonParameter& python_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PythonParameter* release_python_param();
  ::opencv_caffe::PythonParameter* mutable_python_param();
  void set_allocated_python_param(::opencv_caffe::PythonParameter* python_param);
  private:
  const ::opencv_caffe::PythonParameter& _internal_python_param() const;
  ::opencv_caffe::PythonParameter* _internal_mutable_python_param();
  public:
  void unsafe_arena_set_allocated_python_param(
      ::opencv_caffe::PythonParameter* python_param);
  ::opencv_caffe::PythonParameter* unsafe_arena_release_python_param();

  // optional .opencv_caffe.PReLUParameter prelu_param = 131;
  bool has_prelu_param() const;
  private:
  bool _internal_has_prelu_param() const;
  public:
  void clear_prelu_param();
  const ::opencv_caffe::PReLUParameter& prelu_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PReLUParameter* release_prelu_param();
  ::opencv_caffe::PReLUParameter* mutable_prelu_param();
  void set_allocated_prelu_param(::opencv_caffe::PReLUParameter* prelu_param);
  private:
  const ::opencv_caffe::PReLUParameter& _internal_prelu_param() const;
  ::opencv_caffe::PReLUParameter* _internal_mutable_prelu_param();
  public:
  void unsafe_arena_set_allocated_prelu_param(
      ::opencv_caffe::PReLUParameter* prelu_param);
  ::opencv_caffe::PReLUParameter* unsafe_arena_release_prelu_param();

  // optional .opencv_caffe.SPPParameter spp_param = 132;
  bool has_spp_param() const;
  private:
  bool _internal_has_spp_param() const;
  public:
  void clear_spp_param();
  const ::opencv_caffe::SPPParameter& spp_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SPPParameter* release_spp_param();
  ::opencv_caffe::SPPParameter* mutable_spp_param();
  void set_allocated_spp_param(::opencv_caffe::SPPParameter* spp_param);
  private:
  const ::opencv_caffe::SPPParameter& _internal_spp_param() const;
  ::opencv_caffe::SPPParameter* _internal_mutable_spp_param();
  public:
  void unsafe_arena_set_allocated_spp_param(
      ::opencv_caffe::SPPParameter* spp_param);
  ::opencv_caffe::SPPParameter* unsafe_arena_release_spp_param();

  // optional .opencv_caffe.ReshapeParameter reshape_param = 133;
  bool has_reshape_param() const;
  private:
  bool _internal_has_reshape_param() const;
  public:
  void clear_reshape_param();
  const ::opencv_caffe::ReshapeParameter& reshape_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ReshapeParameter* release_reshape_param();
  ::opencv_caffe::ReshapeParameter* mutable_reshape_param();
  void set_allocated_reshape_param(::opencv_caffe::ReshapeParameter* reshape_param);
  private:
  const ::opencv_caffe::ReshapeParameter& _internal_reshape_param() const;
  ::opencv_caffe::ReshapeParameter* _internal_mutable_reshape_param();
  public:
  void unsafe_arena_set_allocated_reshape_param(
      ::opencv_caffe::ReshapeParameter* reshape_param);
  ::opencv_caffe::ReshapeParameter* unsafe_arena_release_reshape_param();

  // optional .opencv_caffe.LogParameter log_param = 134;
  bool has_log_param() const;
  private:
  bool _internal_has_log_param() const;
  public:
  void clear_log_param();
  const ::opencv_caffe::LogParameter& log_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::LogParameter* release_log_param();
  ::opencv_caffe::LogParameter* mutable_log_param();
  void set_allocated_log_param(::opencv_caffe::LogParameter* log_param);
  private:
  const ::opencv_caffe::LogParameter& _internal_log_param() const;
  ::opencv_caffe::LogParameter* _internal_mutable_log_param();
  public:
  void unsafe_arena_set_allocated_log_param(
      ::opencv_caffe::LogParameter* log_param);
  ::opencv_caffe::LogParameter* unsafe_arena_release_log_param();

  // optional .opencv_caffe.FlattenParameter flatten_param = 135;
  bool has_flatten_param() const;
  private:
  bool _internal_has_flatten_param() const;
  public:
  void clear_flatten_param();
  const ::opencv_caffe::FlattenParameter& flatten_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FlattenParameter* release_flatten_param();
  ::opencv_caffe::FlattenParameter* mutable_flatten_param();
  void set_allocated_flatten_param(::opencv_caffe::FlattenParameter* flatten_param);
  private:
  const ::opencv_caffe::FlattenParameter& _internal_flatten_param() const;
  ::opencv_caffe::FlattenParameter* _internal_mutable_flatten_param();
  public:
  void unsafe_arena_set_allocated_flatten_param(
      ::opencv_caffe::FlattenParameter* flatten_param);
  ::opencv_caffe::FlattenParameter* unsafe_arena_release_flatten_param();

  // optional .opencv_caffe.ReductionParameter reduction_param = 136;
  bool has_reduction_param() const;
  private:
  bool _internal_has_reduction_param() const;
  public:
  void clear_reduction_param();
  const ::opencv_caffe::ReductionParameter& reduction_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ReductionParameter* release_reduction_param();
  ::opencv_caffe::ReductionParameter* mutable_reduction_param();
  void set_allocated_reduction_param(::opencv_caffe::ReductionParameter* reduction_param);
  private:
  const ::opencv_caffe::ReductionParameter& _internal_reduction_param() const;
  ::opencv_caffe::ReductionParameter* _internal_mutable_reduction_param();
  public:
  void unsafe_arena_set_allocated_reduction_param(
      ::opencv_caffe::ReductionParameter* reduction_param);
  ::opencv_caffe::ReductionParameter* unsafe_arena_release_reduction_param();

  // optional .opencv_caffe.EmbedParameter embed_param = 137;
  bool has_embed_param() const;
  private:
  bool _internal_has_embed_param() const;
  public:
  void clear_embed_param();
  const ::opencv_caffe::EmbedParameter& embed_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::EmbedParameter* release_embed_param();
  ::opencv_caffe::EmbedParameter* mutable_embed_param();
  void set_allocated_embed_param(::opencv_caffe::EmbedParameter* embed_param);
  private:
  const ::opencv_caffe::EmbedParameter& _internal_embed_param() const;
  ::opencv_caffe::EmbedParameter* _internal_mutable_embed_param();
  public:
  void unsafe_arena_set_allocated_embed_param(
      ::opencv_caffe::EmbedParameter* embed_param);
  ::opencv_caffe::EmbedParameter* unsafe_arena_release_embed_param();

  // optional .opencv_caffe.TileParameter tile_param = 138;
  bool has_tile_param() const;
  private:
  bool _internal_has_tile_param() const;
  public:
  void clear_tile_param();
  const ::opencv_caffe::TileParameter& tile_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::TileParameter* release_tile_param();
  ::opencv_caffe::TileParameter* mutable_tile_param();
  void set_allocated_tile_param(::opencv_caffe::TileParameter* tile_param);
  private:
  const ::opencv_caffe::TileParameter& _internal_tile_param() const;
  ::opencv_caffe::TileParameter* _internal_mutable_tile_param();
  public:
  void unsafe_arena_set_allocated_tile_param(
      ::opencv_caffe::TileParameter* tile_param);
  ::opencv_caffe::TileParameter* unsafe_arena_release_tile_param();

  // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
  bool has_batch_norm_param() const;
  private:
  bool _internal_has_batch_norm_param() const;
  public:
  void clear_batch_norm_param();
  const ::opencv_caffe::BatchNormParameter& batch_norm_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::BatchNormParameter* release_batch_norm_param();
  ::opencv_caffe::BatchNormParameter* mutable_batch_norm_param();
  void set_allocated_batch_norm_param(::opencv_caffe::BatchNormParameter* batch_norm_param);
  private:
  const ::opencv_caffe::BatchNormParameter& _internal_batch_norm_param() const;
  ::opencv_caffe::BatchNormParameter* _internal_mutable_batch_norm_param();
  public:
  void unsafe_arena_set_allocated_batch_norm_param(
      ::opencv_caffe::BatchNormParameter* batch_norm_param);
  ::opencv_caffe::BatchNormParameter* unsafe_arena_release_batch_norm_param();

  // optional .opencv_caffe.ELUParameter elu_param = 140;
  bool has_elu_param() const;
  private:
  bool _internal_has_elu_param() const;
  public:
  void clear_elu_param();
  const ::opencv_caffe::ELUParameter& elu_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ELUParameter* release_elu_param();
  ::opencv_caffe::ELUParameter* mutable_elu_param();
  void set_allocated_elu_param(::opencv_caffe::ELUParameter* elu_param);
  private:
  const ::opencv_caffe::ELUParameter& _internal_elu_param() const;
  ::opencv_caffe::ELUParameter* _internal_mutable_elu_param();
  public:
  void unsafe_arena_set_allocated_elu_param(
      ::opencv_caffe::ELUParameter* elu_param);
  ::opencv_caffe::ELUParameter* unsafe_arena_release_elu_param();

  // optional .opencv_caffe.BiasParameter bias_param = 141;
  bool has_bias_param() const;
  private:
  bool _internal_has_bias_param() const;
  public:
  void clear_bias_param();
  const ::opencv_caffe::BiasParameter& bias_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::BiasParameter* release_bias_param();
  ::opencv_caffe::BiasParameter* mutable_bias_param();
  void set_allocated_bias_param(::opencv_caffe::BiasParameter* bias_param);
  private:
  const ::opencv_caffe::BiasParameter& _internal_bias_param() const;
  ::opencv_caffe::BiasParameter* _internal_mutable_bias_param();
  public:
  void unsafe_arena_set_allocated_bias_param(
      ::opencv_caffe::BiasParameter* bias_param);
  ::opencv_caffe::BiasParameter* unsafe_arena_release_bias_param();

  // optional .opencv_caffe.ScaleParameter scale_param = 142;
  bool has_scale_param() const;
  private:
  bool _internal_has_scale_param() const;
  public:
  void clear_scale_param();
  const ::opencv_caffe::ScaleParameter& scale_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ScaleParameter* release_scale_param();
  ::opencv_caffe::ScaleParameter* mutable_scale_param();
  void set_allocated_scale_param(::opencv_caffe::ScaleParameter* scale_param);
  private:
  const ::opencv_caffe::ScaleParameter& _internal_scale_param() const;
  ::opencv_caffe::ScaleParameter* _internal_mutable_scale_param();
  public:
  void unsafe_arena_set_allocated_scale_param(
      ::opencv_caffe::ScaleParameter* scale_param);
  ::opencv_caffe::ScaleParameter* unsafe_arena_release_scale_param();

  // optional .opencv_caffe.InputParameter input_param = 143;
  bool has_input_param() const;
  private:
  bool _internal_has_input_param() const;
  public:
  void clear_input_param();
  const ::opencv_caffe::InputParameter& input_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::InputParameter* release_input_param();
  ::opencv_caffe::InputParameter* mutable_input_param();
  void set_allocated_input_param(::opencv_caffe::InputParameter* input_param);
  private:
  const ::opencv_caffe::InputParameter& _internal_input_param() const;
  ::opencv_caffe::InputParameter* _internal_mutable_input_param();
  public:
  void unsafe_arena_set_allocated_input_param(
      ::opencv_caffe::InputParameter* input_param);
  ::opencv_caffe::InputParameter* unsafe_arena_release_input_param();

  // optional .opencv_caffe.CropParameter crop_param = 144;
  bool has_crop_param() const;
  private:
  bool _internal_has_crop_param() const;
  public:
  void clear_crop_param();
  const ::opencv_caffe::CropParameter& crop_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::CropParameter* release_crop_param();
  ::opencv_caffe::CropParameter* mutable_crop_param();
  void set_allocated_crop_param(::opencv_caffe::CropParameter* crop_param);
  private:
  const ::opencv_caffe::CropParameter& _internal_crop_param() const;
  ::opencv_caffe::CropParameter* _internal_mutable_crop_param();
  public:
  void unsafe_arena_set_allocated_crop_param(
      ::opencv_caffe::CropParameter* crop_param);
  ::opencv_caffe::CropParameter* unsafe_arena_release_crop_param();

  // optional .opencv_caffe.ParameterParameter parameter_param = 145;
  bool has_parameter_param() const;
  private:
  bool _internal_has_parameter_param() const;
  public:
  void clear_parameter_param();
  const ::opencv_caffe::ParameterParameter& parameter_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ParameterParameter* release_parameter_param();
  ::opencv_caffe::ParameterParameter* mutable_parameter_param();
  void set_allocated_parameter_param(::opencv_caffe::ParameterParameter* parameter_param);
  private:
  const ::opencv_caffe::ParameterParameter& _internal_parameter_param() const;
  ::opencv_caffe::ParameterParameter* _internal_mutable_parameter_param();
  public:
  void unsafe_arena_set_allocated_parameter_param(
      ::opencv_caffe::ParameterParameter* parameter_param);
  ::opencv_caffe::ParameterParameter* unsafe_arena_release_parameter_param();

  // optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
  bool has_recurrent_param() const;
  private:
  bool _internal_has_recurrent_param() const;
  public:
  void clear_recurrent_param();
  const ::opencv_caffe::RecurrentParameter& recurrent_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::RecurrentParameter* release_recurrent_param();
  ::opencv_caffe::RecurrentParameter* mutable_recurrent_param();
  void set_allocated_recurrent_param(::opencv_caffe::RecurrentParameter* recurrent_param);
  private:
  const ::opencv_caffe::RecurrentParameter& _internal_recurrent_param() const;
  ::opencv_caffe::RecurrentParameter* _internal_mutable_recurrent_param();
  public:
  void unsafe_arena_set_allocated_recurrent_param(
      ::opencv_caffe::RecurrentParameter* recurrent_param);
  ::opencv_caffe::RecurrentParameter* unsafe_arena_release_recurrent_param();

  // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
  bool has_detection_output_param() const;
  private:
  bool _internal_has_detection_output_param() const;
  public:
  void clear_detection_output_param();
  const ::opencv_caffe::DetectionOutputParameter& detection_output_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DetectionOutputParameter* release_detection_output_param();
  ::opencv_caffe::DetectionOutputParameter* mutable_detection_output_param();
  void set_allocated_detection_output_param(::opencv_caffe::DetectionOutputParameter* detection_output_param);
  private:
  const ::opencv_caffe::DetectionOutputParameter& _internal_detection_output_param() const;
  ::opencv_caffe::DetectionOutputParameter* _internal_mutable_detection_output_param();
  public:
  void unsafe_arena_set_allocated_detection_output_param(
      ::opencv_caffe::DetectionOutputParameter* detection_output_param);
  ::opencv_caffe::DetectionOutputParameter* unsafe_arena_release_detection_output_param();

  // optional .opencv_caffe.PermuteParameter permute_param = 148;
  bool has_permute_param() const;
  private:
  bool _internal_has_permute_param() const;
  public:
  void clear_permute_param();
  const ::opencv_caffe::PermuteParameter& permute_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PermuteParameter* release_permute_param();
  ::opencv_caffe::PermuteParameter* mutable_permute_param();
  void set_allocated_permute_param(::opencv_caffe::PermuteParameter* permute_param);
  private:
  const ::opencv_caffe::PermuteParameter& _internal_permute_param() const;
  ::opencv_caffe::PermuteParameter* _internal_mutable_permute_param();
  public:
  void unsafe_arena_set_allocated_permute_param(
      ::opencv_caffe::PermuteParameter* permute_param);
  ::opencv_caffe::PermuteParameter* unsafe_arena_release_permute_param();

  // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
  bool has_norm_param() const;
  private:
  bool _internal_has_norm_param() const;
  public:
  void clear_norm_param();
  const ::opencv_caffe::NormalizeBBoxParameter& norm_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::NormalizeBBoxParameter* release_norm_param();
  ::opencv_caffe::NormalizeBBoxParameter* mutable_norm_param();
  void set_allocated_norm_param(::opencv_caffe::NormalizeBBoxParameter* norm_param);
  private:
  const ::opencv_caffe::NormalizeBBoxParameter& _internal_norm_param() const;
  ::opencv_caffe::NormalizeBBoxParameter* _internal_mutable_norm_param();
  public:
  void unsafe_arena_set_allocated_norm_param(
      ::opencv_caffe::NormalizeBBoxParameter* norm_param);
  ::opencv_caffe::NormalizeBBoxParameter* unsafe_arena_release_norm_param();

  // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
  bool has_prior_box_param() const;
  private:
  bool _internal_has_prior_box_param() const;
  public:
  void clear_prior_box_param();
  const ::opencv_caffe::PriorBoxParameter& prior_box_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PriorBoxParameter* release_prior_box_param();
  ::opencv_caffe::PriorBoxParameter* mutable_prior_box_param();
  void set_allocated_prior_box_param(::opencv_caffe::PriorBoxParameter* prior_box_param);
  private:
  const ::opencv_caffe::PriorBoxParameter& _internal_prior_box_param() const;
  ::opencv_caffe::PriorBoxParameter* _internal_mutable_prior_box_param();
  public:
  void unsafe_arena_set_allocated_prior_box_param(
      ::opencv_caffe::PriorBoxParameter* prior_box_param);
  ::opencv_caffe::PriorBoxParameter* unsafe_arena_release_prior_box_param();

  // optional .opencv_caffe.ProposalParameter proposal_param = 201;
  bool has_proposal_param() const;
  private:
  bool _internal_has_proposal_param() const;
  public:
  void clear_proposal_param();
  const ::opencv_caffe::ProposalParameter& proposal_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ProposalParameter* release_proposal_param();
  ::opencv_caffe::ProposalParameter* mutable_proposal_param();
  void set_allocated_proposal_param(::opencv_caffe::ProposalParameter* proposal_param);
  private:
  const ::opencv_caffe::ProposalParameter& _internal_proposal_param() const;
  ::opencv_caffe::ProposalParameter* _internal_mutable_proposal_param();
  public:
  void unsafe_arena_set_allocated_proposal_param(
      ::opencv_caffe::ProposalParameter* proposal_param);
  ::opencv_caffe::ProposalParameter* unsafe_arena_release_proposal_param();

  // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
  bool has_psroi_pooling_param() const;
  private:
  bool _internal_has_psroi_pooling_param() const;
  public:
  void clear_psroi_pooling_param();
  const ::opencv_caffe::PSROIPoolingParameter& psroi_pooling_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PSROIPoolingParameter* release_psroi_pooling_param();
  ::opencv_caffe::PSROIPoolingParameter* mutable_psroi_pooling_param();
  void set_allocated_psroi_pooling_param(::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param);
  private:
  const ::opencv_caffe::PSROIPoolingParameter& _internal_psroi_pooling_param() const;
  ::opencv_caffe::PSROIPoolingParameter* _internal_mutable_psroi_pooling_param();
  public:
  void unsafe_arena_set_allocated_psroi_pooling_param(
      ::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param);
  ::opencv_caffe::PSROIPoolingParameter* unsafe_arena_release_psroi_pooling_param();

  // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
  bool has_roi_pooling_param() const;
  private:
  bool _internal_has_roi_pooling_param() const;
  public:
  void clear_roi_pooling_param();
  const ::opencv_caffe::ROIPoolingParameter& roi_pooling_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ROIPoolingParameter* release_roi_pooling_param();
  ::opencv_caffe::ROIPoolingParameter* mutable_roi_pooling_param();
  void set_allocated_roi_pooling_param(::opencv_caffe::ROIPoolingParameter* roi_pooling_param);
  private:
  const ::opencv_caffe::ROIPoolingParameter& _internal_roi_pooling_param() const;
  ::opencv_caffe::ROIPoolingParameter* _internal_mutable_roi_pooling_param();
  public:
  void unsafe_arena_set_allocated_roi_pooling_param(
      ::opencv_caffe::ROIPoolingParameter* roi_pooling_param);
  ::opencv_caffe::ROIPoolingParameter* unsafe_arena_release_roi_pooling_param();

  // optional .opencv_caffe.Phase phase = 10;
  bool has_phase() const;
  private:
  bool _internal_has_phase() const;
  public:
  void clear_phase();
  ::opencv_caffe::Phase phase() const;
  void set_phase(::opencv_caffe::Phase value);
  private:
  ::opencv_caffe::Phase _internal_phase() const;
  void _internal_set_phase(::opencv_caffe::Phase value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.LayerParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bottom_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> top_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > loss_weight_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec > param_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > include_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > exclude_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > propagate_down_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
    ::opencv_caffe::TransformationParameter* transform_param_;
    ::opencv_caffe::LossParameter* loss_param_;
    ::opencv_caffe::AccuracyParameter* accuracy_param_;
    ::opencv_caffe::ArgMaxParameter* argmax_param_;
    ::opencv_caffe::ConcatParameter* concat_param_;
    ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param_;
    ::opencv_caffe::ConvolutionParameter* convolution_param_;
    ::opencv_caffe::DataParameter* data_param_;
    ::opencv_caffe::DropoutParameter* dropout_param_;
    ::opencv_caffe::DummyDataParameter* dummy_data_param_;
    ::opencv_caffe::EltwiseParameter* eltwise_param_;
    ::opencv_caffe::ExpParameter* exp_param_;
    ::opencv_caffe::HDF5DataParameter* hdf5_data_param_;
    ::opencv_caffe::HDF5OutputParameter* hdf5_output_param_;
    ::opencv_caffe::HingeLossParameter* hinge_loss_param_;
    ::opencv_caffe::ImageDataParameter* image_data_param_;
    ::opencv_caffe::InfogainLossParameter* infogain_loss_param_;
    ::opencv_caffe::InnerProductParameter* inner_product_param_;
    ::opencv_caffe::LRNParameter* lrn_param_;
    ::opencv_caffe::MemoryDataParameter* memory_data_param_;
    ::opencv_caffe::MVNParameter* mvn_param_;
    ::opencv_caffe::PoolingParameter* pooling_param_;
    ::opencv_caffe::PowerParameter* power_param_;
    ::opencv_caffe::ReLUParameter* relu_param_;
    ::opencv_caffe::SigmoidParameter* sigmoid_param_;
    ::opencv_caffe::SoftmaxParameter* softmax_param_;
    ::opencv_caffe::SliceParameter* slice_param_;
    ::opencv_caffe::TanHParameter* tanh_param_;
    ::opencv_caffe::ThresholdParameter* threshold_param_;
    ::opencv_caffe::WindowDataParameter* window_data_param_;
    ::opencv_caffe::PythonParameter* python_param_;
    ::opencv_caffe::PReLUParameter* prelu_param_;
    ::opencv_caffe::SPPParameter* spp_param_;
    ::opencv_caffe::ReshapeParameter* reshape_param_;
    ::opencv_caffe::LogParameter* log_param_;
    ::opencv_caffe::FlattenParameter* flatten_param_;
    ::opencv_caffe::ReductionParameter* reduction_param_;
    ::opencv_caffe::EmbedParameter* embed_param_;
    ::opencv_caffe::TileParameter* tile_param_;
    ::opencv_caffe::BatchNormParameter* batch_norm_param_;
    ::opencv_caffe::ELUParameter* elu_param_;
    ::opencv_caffe::BiasParameter* bias_param_;
    ::opencv_caffe::ScaleParameter* scale_param_;
    ::opencv_caffe::InputParameter* input_param_;
    ::opencv_caffe::CropParameter* crop_param_;
    ::opencv_caffe::ParameterParameter* parameter_param_;
    ::opencv_caffe::RecurrentParameter* recurrent_param_;
    ::opencv_caffe::DetectionOutputParameter* detection_output_param_;
    ::opencv_caffe::PermuteParameter* permute_param_;
    ::opencv_caffe::NormalizeBBoxParameter* norm_param_;
    ::opencv_caffe::PriorBoxParameter* prior_box_param_;
    ::opencv_caffe::ProposalParameter* proposal_param_;
    ::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param_;
    ::opencv_caffe::ROIPoolingParameter* roi_pooling_param_;
    int phase_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class TransformationParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TransformationParameter) */ {
 public:
  inline TransformationParameter() : TransformationParameter(nullptr) {}
  ~TransformationParameter() override;
  explicit PROTOBUF_CONSTEXPR TransformationParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TransformationParameter& operator=(const TransformationParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline TransformationParameter& operator=(TransformationParameter&& 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 TransformationParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const TransformationParameter* internal_default_instance() {
    return reinterpret_cast<const TransformationParameter*>(
               &_TransformationParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(TransformationParameter& a, TransformationParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(TransformationParameter* 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(TransformationParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TransformationParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TransformationParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TransformationParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TransformationParameter& from) {
    TransformationParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TransformationParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.TransformationParameter";
  }
  protected:
  explicit TransformationParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kMeanValueFieldNumber = 5,
    kMeanFileFieldNumber = 4,
    kCropSizeFieldNumber = 3,
    kMirrorFieldNumber = 2,
    kForceColorFieldNumber = 6,
    kForceGrayFieldNumber = 7,
    kScaleFieldNumber = 1,
  };
  // repeated float mean_value = 5;
  int mean_value_size() const;
  private:
  int _internal_mean_value_size() const;
  public:
  void clear_mean_value();
  private:
  float _internal_mean_value(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_mean_value() const;
  void _internal_add_mean_value(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_mean_value();
  public:
  float mean_value(int index) const;
  void set_mean_value(int index, float value);
  void add_mean_value(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      mean_value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_mean_value();

  // optional string mean_file = 4;
  bool has_mean_file() const;
  private:
  bool _internal_has_mean_file() const;
  public:
  void clear_mean_file();
  const std::string& mean_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mean_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mean_file();
  PROTOBUF_NODISCARD std::string* release_mean_file();
  void set_allocated_mean_file(std::string* mean_file);
  private:
  const std::string& _internal_mean_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
  std::string* _internal_mutable_mean_file();
  public:

  // optional uint32 crop_size = 3 [default = 0];
  bool has_crop_size() const;
  private:
  bool _internal_has_crop_size() const;
  public:
  void clear_crop_size();
  uint32_t crop_size() const;
  void set_crop_size(uint32_t value);
  private:
  uint32_t _internal_crop_size() const;
  void _internal_set_crop_size(uint32_t value);
  public:

  // optional bool mirror = 2 [default = false];
  bool has_mirror() const;
  private:
  bool _internal_has_mirror() const;
  public:
  void clear_mirror();
  bool mirror() const;
  void set_mirror(bool value);
  private:
  bool _internal_mirror() const;
  void _internal_set_mirror(bool value);
  public:

  // optional bool force_color = 6 [default = false];
  bool has_force_color() const;
  private:
  bool _internal_has_force_color() const;
  public:
  void clear_force_color();
  bool force_color() const;
  void set_force_color(bool value);
  private:
  bool _internal_force_color() const;
  void _internal_set_force_color(bool value);
  public:

  // optional bool force_gray = 7 [default = false];
  bool has_force_gray() const;
  private:
  bool _internal_has_force_gray() const;
  public:
  void clear_force_gray();
  bool force_gray() const;
  void set_force_gray(bool value);
  private:
  bool _internal_force_gray() const;
  void _internal_set_force_gray(bool value);
  public:

  // optional float scale = 1 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.TransformationParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > mean_value_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
    uint32_t crop_size_;
    bool mirror_;
    bool force_color_;
    bool force_gray_;
    float scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class LossParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LossParameter) */ {
 public:
  inline LossParameter() : LossParameter(nullptr) {}
  ~LossParameter() override;
  explicit PROTOBUF_CONSTEXPR LossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LossParameter& operator=(const LossParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline LossParameter& operator=(LossParameter&& 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 LossParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const LossParameter* internal_default_instance() {
    return reinterpret_cast<const LossParameter*>(
               &_LossParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(LossParameter& a, LossParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(LossParameter* 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(LossParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LossParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LossParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LossParameter& from) {
    LossParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LossParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.LossParameter";
  }
  protected:
  explicit LossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 LossParameter_NormalizationMode NormalizationMode;
  static constexpr NormalizationMode FULL =
    LossParameter_NormalizationMode_FULL;
  static constexpr NormalizationMode VALID =
    LossParameter_NormalizationMode_VALID;
  static constexpr NormalizationMode BATCH_SIZE =
    LossParameter_NormalizationMode_BATCH_SIZE;
  static constexpr NormalizationMode NONE =
    LossParameter_NormalizationMode_NONE;
  static inline bool NormalizationMode_IsValid(int value) {
    return LossParameter_NormalizationMode_IsValid(value);
  }
  static constexpr NormalizationMode NormalizationMode_MIN =
    LossParameter_NormalizationMode_NormalizationMode_MIN;
  static constexpr NormalizationMode NormalizationMode_MAX =
    LossParameter_NormalizationMode_NormalizationMode_MAX;
  static constexpr int NormalizationMode_ARRAYSIZE =
    LossParameter_NormalizationMode_NormalizationMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  NormalizationMode_descriptor() {
    return LossParameter_NormalizationMode_descriptor();
  }
  template<typename T>
  static inline const std::string& NormalizationMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, NormalizationMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function NormalizationMode_Name.");
    return LossParameter_NormalizationMode_Name(enum_t_value);
  }
  static inline bool NormalizationMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      NormalizationMode* value) {
    return LossParameter_NormalizationMode_Parse(name, value);
  }

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

  enum : int {
    kIgnoreLabelFieldNumber = 1,
    kNormalizeFieldNumber = 2,
    kNormalizationFieldNumber = 3,
  };
  // optional int32 ignore_label = 1;
  bool has_ignore_label() const;
  private:
  bool _internal_has_ignore_label() const;
  public:
  void clear_ignore_label();
  int32_t ignore_label() const;
  void set_ignore_label(int32_t value);
  private:
  int32_t _internal_ignore_label() const;
  void _internal_set_ignore_label(int32_t value);
  public:

  // optional bool normalize = 2;
  bool has_normalize() const;
  private:
  bool _internal_has_normalize() const;
  public:
  void clear_normalize();
  bool normalize() const;
  void set_normalize(bool value);
  private:
  bool _internal_normalize() const;
  void _internal_set_normalize(bool value);
  public:

  // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
  bool has_normalization() const;
  private:
  bool _internal_has_normalization() const;
  public:
  void clear_normalization();
  ::opencv_caffe::LossParameter_NormalizationMode normalization() const;
  void set_normalization(::opencv_caffe::LossParameter_NormalizationMode value);
  private:
  ::opencv_caffe::LossParameter_NormalizationMode _internal_normalization() const;
  void _internal_set_normalization(::opencv_caffe::LossParameter_NormalizationMode value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.LossParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t ignore_label_;
    bool normalize_;
    int normalization_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class AccuracyParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.AccuracyParameter) */ {
 public:
  inline AccuracyParameter() : AccuracyParameter(nullptr) {}
  ~AccuracyParameter() override;
  explicit PROTOBUF_CONSTEXPR AccuracyParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline AccuracyParameter& operator=(const AccuracyParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline AccuracyParameter& operator=(AccuracyParameter&& 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 AccuracyParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const AccuracyParameter* internal_default_instance() {
    return reinterpret_cast<const AccuracyParameter*>(
               &_AccuracyParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(AccuracyParameter& a, AccuracyParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(AccuracyParameter* 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(AccuracyParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AccuracyParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AccuracyParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AccuracyParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AccuracyParameter& from) {
    AccuracyParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AccuracyParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.AccuracyParameter";
  }
  protected:
  explicit AccuracyParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kIgnoreLabelFieldNumber = 3,
    kTopKFieldNumber = 1,
    kAxisFieldNumber = 2,
  };
  // optional int32 ignore_label = 3;
  bool has_ignore_label() const;
  private:
  bool _internal_has_ignore_label() const;
  public:
  void clear_ignore_label();
  int32_t ignore_label() const;
  void set_ignore_label(int32_t value);
  private:
  int32_t _internal_ignore_label() const;
  void _internal_set_ignore_label(int32_t value);
  public:

  // optional uint32 top_k = 1 [default = 1];
  bool has_top_k() const;
  private:
  bool _internal_has_top_k() const;
  public:
  void clear_top_k();
  uint32_t top_k() const;
  void set_top_k(uint32_t value);
  private:
  uint32_t _internal_top_k() const;
  void _internal_set_top_k(uint32_t value);
  public:

  // optional int32 axis = 2 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.AccuracyParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t ignore_label_;
    uint32_t top_k_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ArgMaxParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ArgMaxParameter) */ {
 public:
  inline ArgMaxParameter() : ArgMaxParameter(nullptr) {}
  ~ArgMaxParameter() override;
  explicit PROTOBUF_CONSTEXPR ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ArgMaxParameter& operator=(const ArgMaxParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ArgMaxParameter& operator=(ArgMaxParameter&& 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 ArgMaxParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ArgMaxParameter* internal_default_instance() {
    return reinterpret_cast<const ArgMaxParameter*>(
               &_ArgMaxParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(ArgMaxParameter& a, ArgMaxParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ArgMaxParameter* 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(ArgMaxParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ArgMaxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ArgMaxParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ArgMaxParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ArgMaxParameter& from) {
    ArgMaxParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ArgMaxParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ArgMaxParameter";
  }
  protected:
  explicit ArgMaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kOutMaxValFieldNumber = 1,
    kAxisFieldNumber = 3,
    kTopKFieldNumber = 2,
  };
  // optional bool out_max_val = 1 [default = false];
  bool has_out_max_val() const;
  private:
  bool _internal_has_out_max_val() const;
  public:
  void clear_out_max_val();
  bool out_max_val() const;
  void set_out_max_val(bool value);
  private:
  bool _internal_out_max_val() const;
  void _internal_set_out_max_val(bool value);
  public:

  // optional int32 axis = 3;
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional uint32 top_k = 2 [default = 1];
  bool has_top_k() const;
  private:
  bool _internal_has_top_k() const;
  public:
  void clear_top_k();
  uint32_t top_k() const;
  void set_top_k(uint32_t value);
  private:
  uint32_t _internal_top_k() const;
  void _internal_set_top_k(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ArgMaxParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool out_max_val_;
    int32_t axis_;
    uint32_t top_k_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ConcatParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ConcatParameter) */ {
 public:
  inline ConcatParameter() : ConcatParameter(nullptr) {}
  ~ConcatParameter() override;
  explicit PROTOBUF_CONSTEXPR ConcatParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ConcatParameter& operator=(const ConcatParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConcatParameter& operator=(ConcatParameter&& 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 ConcatParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConcatParameter* internal_default_instance() {
    return reinterpret_cast<const ConcatParameter*>(
               &_ConcatParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(ConcatParameter& a, ConcatParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ConcatParameter* 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(ConcatParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ConcatParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConcatParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConcatParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ConcatParameter& from) {
    ConcatParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConcatParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ConcatParameter";
  }
  protected:
  explicit ConcatParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kConcatDimFieldNumber = 1,
    kAxisFieldNumber = 2,
  };
  // optional uint32 concat_dim = 1 [default = 1];
  bool has_concat_dim() const;
  private:
  bool _internal_has_concat_dim() const;
  public:
  void clear_concat_dim();
  uint32_t concat_dim() const;
  void set_concat_dim(uint32_t value);
  private:
  uint32_t _internal_concat_dim() const;
  void _internal_set_concat_dim(uint32_t value);
  public:

  // optional int32 axis = 2 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ConcatParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t concat_dim_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class BatchNormParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BatchNormParameter) */ {
 public:
  inline BatchNormParameter() : BatchNormParameter(nullptr) {}
  ~BatchNormParameter() override;
  explicit PROTOBUF_CONSTEXPR BatchNormParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BatchNormParameter& operator=(const BatchNormParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline BatchNormParameter& operator=(BatchNormParameter&& 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 BatchNormParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const BatchNormParameter* internal_default_instance() {
    return reinterpret_cast<const BatchNormParameter*>(
               &_BatchNormParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(BatchNormParameter& a, BatchNormParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(BatchNormParameter* 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(BatchNormParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BatchNormParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BatchNormParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BatchNormParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BatchNormParameter& from) {
    BatchNormParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BatchNormParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.BatchNormParameter";
  }
  protected:
  explicit BatchNormParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kUseGlobalStatsFieldNumber = 1,
    kScaleBiasFieldNumber = 7,
    kMovingAverageFractionFieldNumber = 2,
    kEpsFieldNumber = 3,
  };
  // optional bool use_global_stats = 1;
  bool has_use_global_stats() const;
  private:
  bool _internal_has_use_global_stats() const;
  public:
  void clear_use_global_stats();
  bool use_global_stats() const;
  void set_use_global_stats(bool value);
  private:
  bool _internal_use_global_stats() const;
  void _internal_set_use_global_stats(bool value);
  public:

  // optional bool scale_bias = 7 [default = false];
  bool has_scale_bias() const;
  private:
  bool _internal_has_scale_bias() const;
  public:
  void clear_scale_bias();
  bool scale_bias() const;
  void set_scale_bias(bool value);
  private:
  bool _internal_scale_bias() const;
  void _internal_set_scale_bias(bool value);
  public:

  // optional float moving_average_fraction = 2 [default = 0.999];
  bool has_moving_average_fraction() const;
  private:
  bool _internal_has_moving_average_fraction() const;
  public:
  void clear_moving_average_fraction();
  float moving_average_fraction() const;
  void set_moving_average_fraction(float value);
  private:
  float _internal_moving_average_fraction() const;
  void _internal_set_moving_average_fraction(float value);
  public:

  // optional float eps = 3 [default = 1e-05];
  bool has_eps() const;
  private:
  bool _internal_has_eps() const;
  public:
  void clear_eps();
  float eps() const;
  void set_eps(float value);
  private:
  float _internal_eps() const;
  void _internal_set_eps(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.BatchNormParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool use_global_stats_;
    bool scale_bias_;
    float moving_average_fraction_;
    float eps_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class BiasParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.BiasParameter) */ {
 public:
  inline BiasParameter() : BiasParameter(nullptr) {}
  ~BiasParameter() override;
  explicit PROTOBUF_CONSTEXPR BiasParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BiasParameter& operator=(const BiasParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline BiasParameter& operator=(BiasParameter&& 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 BiasParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const BiasParameter* internal_default_instance() {
    return reinterpret_cast<const BiasParameter*>(
               &_BiasParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(BiasParameter& a, BiasParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(BiasParameter* 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(BiasParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BiasParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BiasParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BiasParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BiasParameter& from) {
    BiasParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BiasParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.BiasParameter";
  }
  protected:
  explicit BiasParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kFillerFieldNumber = 3,
    kAxisFieldNumber = 1,
    kNumAxesFieldNumber = 2,
  };
  // optional .opencv_caffe.FillerParameter filler = 3;
  bool has_filler() const;
  private:
  bool _internal_has_filler() const;
  public:
  void clear_filler();
  const ::opencv_caffe::FillerParameter& filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_filler();
  ::opencv_caffe::FillerParameter* mutable_filler();
  void set_allocated_filler(::opencv_caffe::FillerParameter* filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_filler();
  public:
  void unsafe_arena_set_allocated_filler(
      ::opencv_caffe::FillerParameter* filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_filler();

  // optional int32 axis = 1 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional int32 num_axes = 2 [default = 1];
  bool has_num_axes() const;
  private:
  bool _internal_has_num_axes() const;
  public:
  void clear_num_axes();
  int32_t num_axes() const;
  void set_num_axes(int32_t value);
  private:
  int32_t _internal_num_axes() const;
  void _internal_set_num_axes(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.BiasParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* filler_;
    int32_t axis_;
    int32_t num_axes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ContrastiveLossParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ContrastiveLossParameter) */ {
 public:
  inline ContrastiveLossParameter() : ContrastiveLossParameter(nullptr) {}
  ~ContrastiveLossParameter() override;
  explicit PROTOBUF_CONSTEXPR ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ContrastiveLossParameter& operator=(const ContrastiveLossParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ContrastiveLossParameter& operator=(ContrastiveLossParameter&& 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 ContrastiveLossParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ContrastiveLossParameter* internal_default_instance() {
    return reinterpret_cast<const ContrastiveLossParameter*>(
               &_ContrastiveLossParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(ContrastiveLossParameter& a, ContrastiveLossParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ContrastiveLossParameter* 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(ContrastiveLossParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ContrastiveLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ContrastiveLossParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ContrastiveLossParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ContrastiveLossParameter& from) {
    ContrastiveLossParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ContrastiveLossParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ContrastiveLossParameter";
  }
  protected:
  explicit ContrastiveLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kLegacyVersionFieldNumber = 2,
    kMarginFieldNumber = 1,
  };
  // optional bool legacy_version = 2 [default = false];
  bool has_legacy_version() const;
  private:
  bool _internal_has_legacy_version() const;
  public:
  void clear_legacy_version();
  bool legacy_version() const;
  void set_legacy_version(bool value);
  private:
  bool _internal_legacy_version() const;
  void _internal_set_legacy_version(bool value);
  public:

  // optional float margin = 1 [default = 1];
  bool has_margin() const;
  private:
  bool _internal_has_margin() const;
  public:
  void clear_margin();
  float margin() const;
  void set_margin(float value);
  private:
  float _internal_margin() const;
  void _internal_set_margin(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ContrastiveLossParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool legacy_version_;
    float margin_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ConvolutionParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ConvolutionParameter) */ {
 public:
  inline ConvolutionParameter() : ConvolutionParameter(nullptr) {}
  ~ConvolutionParameter() override;
  explicit PROTOBUF_CONSTEXPR ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ConvolutionParameter& operator=(const ConvolutionParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConvolutionParameter& operator=(ConvolutionParameter&& 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 ConvolutionParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConvolutionParameter* internal_default_instance() {
    return reinterpret_cast<const ConvolutionParameter*>(
               &_ConvolutionParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(ConvolutionParameter& a, ConvolutionParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ConvolutionParameter* 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(ConvolutionParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ConvolutionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConvolutionParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConvolutionParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ConvolutionParameter& from) {
    ConvolutionParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConvolutionParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ConvolutionParameter";
  }
  protected:
  explicit ConvolutionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 ConvolutionParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    ConvolutionParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    ConvolutionParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    ConvolutionParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return ConvolutionParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    ConvolutionParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    ConvolutionParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    ConvolutionParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return ConvolutionParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return ConvolutionParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return ConvolutionParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kPadFieldNumber = 3,
    kKernelSizeFieldNumber = 4,
    kStrideFieldNumber = 6,
    kDilationFieldNumber = 18,
    kWeightFillerFieldNumber = 7,
    kBiasFillerFieldNumber = 8,
    kNumOutputFieldNumber = 1,
    kPadHFieldNumber = 9,
    kPadWFieldNumber = 10,
    kKernelHFieldNumber = 11,
    kKernelWFieldNumber = 12,
    kStrideHFieldNumber = 13,
    kStrideWFieldNumber = 14,
    kEngineFieldNumber = 15,
    kForceNdIm2ColFieldNumber = 17,
    kAxisFieldNumber = 16,
    kBiasTermFieldNumber = 2,
    kGroupFieldNumber = 5,
  };
  // repeated uint32 pad = 3;
  int pad_size() const;
  private:
  int _internal_pad_size() const;
  public:
  void clear_pad();
  private:
  uint32_t _internal_pad(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_pad() const;
  void _internal_add_pad(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_pad();
  public:
  uint32_t pad(int index) const;
  void set_pad(int index, uint32_t value);
  void add_pad(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      pad() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_pad();

  // repeated uint32 kernel_size = 4;
  int kernel_size_size() const;
  private:
  int _internal_kernel_size_size() const;
  public:
  void clear_kernel_size();
  private:
  uint32_t _internal_kernel_size(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_kernel_size() const;
  void _internal_add_kernel_size(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_kernel_size();
  public:
  uint32_t kernel_size(int index) const;
  void set_kernel_size(int index, uint32_t value);
  void add_kernel_size(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      kernel_size() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_kernel_size();

  // repeated uint32 stride = 6;
  int stride_size() const;
  private:
  int _internal_stride_size() const;
  public:
  void clear_stride();
  private:
  uint32_t _internal_stride(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_stride() const;
  void _internal_add_stride(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_stride();
  public:
  uint32_t stride(int index) const;
  void set_stride(int index, uint32_t value);
  void add_stride(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      stride() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_stride();

  // repeated uint32 dilation = 18;
  int dilation_size() const;
  private:
  int _internal_dilation_size() const;
  public:
  void clear_dilation();
  private:
  uint32_t _internal_dilation(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_dilation() const;
  void _internal_add_dilation(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_dilation();
  public:
  uint32_t dilation(int index) const;
  void set_dilation(int index, uint32_t value);
  void add_dilation(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      dilation() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_dilation();

  // optional .opencv_caffe.FillerParameter weight_filler = 7;
  bool has_weight_filler() const;
  private:
  bool _internal_has_weight_filler() const;
  public:
  void clear_weight_filler();
  const ::opencv_caffe::FillerParameter& weight_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler();
  ::opencv_caffe::FillerParameter* mutable_weight_filler();
  void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_weight_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler();
  public:
  void unsafe_arena_set_allocated_weight_filler(
      ::opencv_caffe::FillerParameter* weight_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler();

  // optional .opencv_caffe.FillerParameter bias_filler = 8;
  bool has_bias_filler() const;
  private:
  bool _internal_has_bias_filler() const;
  public:
  void clear_bias_filler();
  const ::opencv_caffe::FillerParameter& bias_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler();
  ::opencv_caffe::FillerParameter* mutable_bias_filler();
  void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_bias_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler();
  public:
  void unsafe_arena_set_allocated_bias_filler(
      ::opencv_caffe::FillerParameter* bias_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler();

  // optional uint32 num_output = 1;
  bool has_num_output() const;
  private:
  bool _internal_has_num_output() const;
  public:
  void clear_num_output();
  uint32_t num_output() const;
  void set_num_output(uint32_t value);
  private:
  uint32_t _internal_num_output() const;
  void _internal_set_num_output(uint32_t value);
  public:

  // optional uint32 pad_h = 9 [default = 0];
  bool has_pad_h() const;
  private:
  bool _internal_has_pad_h() const;
  public:
  void clear_pad_h();
  uint32_t pad_h() const;
  void set_pad_h(uint32_t value);
  private:
  uint32_t _internal_pad_h() const;
  void _internal_set_pad_h(uint32_t value);
  public:

  // optional uint32 pad_w = 10 [default = 0];
  bool has_pad_w() const;
  private:
  bool _internal_has_pad_w() const;
  public:
  void clear_pad_w();
  uint32_t pad_w() const;
  void set_pad_w(uint32_t value);
  private:
  uint32_t _internal_pad_w() const;
  void _internal_set_pad_w(uint32_t value);
  public:

  // optional uint32 kernel_h = 11;
  bool has_kernel_h() const;
  private:
  bool _internal_has_kernel_h() const;
  public:
  void clear_kernel_h();
  uint32_t kernel_h() const;
  void set_kernel_h(uint32_t value);
  private:
  uint32_t _internal_kernel_h() const;
  void _internal_set_kernel_h(uint32_t value);
  public:

  // optional uint32 kernel_w = 12;
  bool has_kernel_w() const;
  private:
  bool _internal_has_kernel_w() const;
  public:
  void clear_kernel_w();
  uint32_t kernel_w() const;
  void set_kernel_w(uint32_t value);
  private:
  uint32_t _internal_kernel_w() const;
  void _internal_set_kernel_w(uint32_t value);
  public:

  // optional uint32 stride_h = 13;
  bool has_stride_h() const;
  private:
  bool _internal_has_stride_h() const;
  public:
  void clear_stride_h();
  uint32_t stride_h() const;
  void set_stride_h(uint32_t value);
  private:
  uint32_t _internal_stride_h() const;
  void _internal_set_stride_h(uint32_t value);
  public:

  // optional uint32 stride_w = 14;
  bool has_stride_w() const;
  private:
  bool _internal_has_stride_w() const;
  public:
  void clear_stride_w();
  uint32_t stride_w() const;
  void set_stride_w(uint32_t value);
  private:
  uint32_t _internal_stride_w() const;
  void _internal_set_stride_w(uint32_t value);
  public:

  // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::ConvolutionParameter_Engine engine() const;
  void set_engine(::opencv_caffe::ConvolutionParameter_Engine value);
  private:
  ::opencv_caffe::ConvolutionParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::ConvolutionParameter_Engine value);
  public:

  // optional bool force_nd_im2col = 17 [default = false];
  bool has_force_nd_im2col() const;
  private:
  bool _internal_has_force_nd_im2col() const;
  public:
  void clear_force_nd_im2col();
  bool force_nd_im2col() const;
  void set_force_nd_im2col(bool value);
  private:
  bool _internal_force_nd_im2col() const;
  void _internal_set_force_nd_im2col(bool value);
  public:

  // optional int32 axis = 16 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional bool bias_term = 2 [default = true];
  bool has_bias_term() const;
  private:
  bool _internal_has_bias_term() const;
  public:
  void clear_bias_term();
  bool bias_term() const;
  void set_bias_term(bool value);
  private:
  bool _internal_bias_term() const;
  void _internal_set_bias_term(bool value);
  public:

  // optional uint32 group = 5 [default = 1];
  bool has_group() const;
  private:
  bool _internal_has_group() const;
  public:
  void clear_group();
  uint32_t group() const;
  void set_group(uint32_t value);
  private:
  uint32_t _internal_group() const;
  void _internal_set_group(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ConvolutionParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > pad_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > kernel_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > stride_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > dilation_;
    ::opencv_caffe::FillerParameter* weight_filler_;
    ::opencv_caffe::FillerParameter* bias_filler_;
    uint32_t num_output_;
    uint32_t pad_h_;
    uint32_t pad_w_;
    uint32_t kernel_h_;
    uint32_t kernel_w_;
    uint32_t stride_h_;
    uint32_t stride_w_;
    int engine_;
    bool force_nd_im2col_;
    int32_t axis_;
    bool bias_term_;
    uint32_t group_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class CropParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.CropParameter) */ {
 public:
  inline CropParameter() : CropParameter(nullptr) {}
  ~CropParameter() override;
  explicit PROTOBUF_CONSTEXPR CropParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline CropParameter& operator=(const CropParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline CropParameter& operator=(CropParameter&& 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 CropParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const CropParameter* internal_default_instance() {
    return reinterpret_cast<const CropParameter*>(
               &_CropParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(CropParameter& a, CropParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(CropParameter* 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(CropParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CropParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CropParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CropParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CropParameter& from) {
    CropParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CropParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.CropParameter";
  }
  protected:
  explicit CropParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kOffsetFieldNumber = 2,
    kAxisFieldNumber = 1,
  };
  // repeated uint32 offset = 2;
  int offset_size() const;
  private:
  int _internal_offset_size() const;
  public:
  void clear_offset();
  private:
  uint32_t _internal_offset(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_offset() const;
  void _internal_add_offset(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_offset();
  public:
  uint32_t offset(int index) const;
  void set_offset(int index, uint32_t value);
  void add_offset(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      offset() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_offset();

  // optional int32 axis = 1 [default = 2];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.CropParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > offset_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class DataParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DataParameter) */ {
 public:
  inline DataParameter() : DataParameter(nullptr) {}
  ~DataParameter() override;
  explicit PROTOBUF_CONSTEXPR DataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DataParameter& operator=(const DataParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataParameter& operator=(DataParameter&& 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 DataParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const DataParameter* internal_default_instance() {
    return reinterpret_cast<const DataParameter*>(
               &_DataParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(DataParameter& a, DataParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(DataParameter* 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(DataParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DataParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DataParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DataParameter& from) {
    DataParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DataParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.DataParameter";
  }
  protected:
  explicit DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 DataParameter_DB DB;
  static constexpr DB LEVELDB =
    DataParameter_DB_LEVELDB;
  static constexpr DB LMDB =
    DataParameter_DB_LMDB;
  static inline bool DB_IsValid(int value) {
    return DataParameter_DB_IsValid(value);
  }
  static constexpr DB DB_MIN =
    DataParameter_DB_DB_MIN;
  static constexpr DB DB_MAX =
    DataParameter_DB_DB_MAX;
  static constexpr int DB_ARRAYSIZE =
    DataParameter_DB_DB_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DB_descriptor() {
    return DataParameter_DB_descriptor();
  }
  template<typename T>
  static inline const std::string& DB_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DB>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DB_Name.");
    return DataParameter_DB_Name(enum_t_value);
  }
  static inline bool DB_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DB* value) {
    return DataParameter_DB_Parse(name, value);
  }

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

  enum : int {
    kSourceFieldNumber = 1,
    kMeanFileFieldNumber = 3,
    kBatchSizeFieldNumber = 4,
    kCropSizeFieldNumber = 5,
    kRandSkipFieldNumber = 7,
    kMirrorFieldNumber = 6,
    kForceEncodedColorFieldNumber = 9,
    kBackendFieldNumber = 8,
    kScaleFieldNumber = 2,
    kPrefetchFieldNumber = 10,
  };
  // optional string source = 1;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional string mean_file = 3;
  bool has_mean_file() const;
  private:
  bool _internal_has_mean_file() const;
  public:
  void clear_mean_file();
  const std::string& mean_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mean_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mean_file();
  PROTOBUF_NODISCARD std::string* release_mean_file();
  void set_allocated_mean_file(std::string* mean_file);
  private:
  const std::string& _internal_mean_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
  std::string* _internal_mutable_mean_file();
  public:

  // optional uint32 batch_size = 4;
  bool has_batch_size() const;
  private:
  bool _internal_has_batch_size() const;
  public:
  void clear_batch_size();
  uint32_t batch_size() const;
  void set_batch_size(uint32_t value);
  private:
  uint32_t _internal_batch_size() const;
  void _internal_set_batch_size(uint32_t value);
  public:

  // optional uint32 crop_size = 5 [default = 0];
  bool has_crop_size() const;
  private:
  bool _internal_has_crop_size() const;
  public:
  void clear_crop_size();
  uint32_t crop_size() const;
  void set_crop_size(uint32_t value);
  private:
  uint32_t _internal_crop_size() const;
  void _internal_set_crop_size(uint32_t value);
  public:

  // optional uint32 rand_skip = 7 [default = 0];
  bool has_rand_skip() const;
  private:
  bool _internal_has_rand_skip() const;
  public:
  void clear_rand_skip();
  uint32_t rand_skip() const;
  void set_rand_skip(uint32_t value);
  private:
  uint32_t _internal_rand_skip() const;
  void _internal_set_rand_skip(uint32_t value);
  public:

  // optional bool mirror = 6 [default = false];
  bool has_mirror() const;
  private:
  bool _internal_has_mirror() const;
  public:
  void clear_mirror();
  bool mirror() const;
  void set_mirror(bool value);
  private:
  bool _internal_mirror() const;
  void _internal_set_mirror(bool value);
  public:

  // optional bool force_encoded_color = 9 [default = false];
  bool has_force_encoded_color() const;
  private:
  bool _internal_has_force_encoded_color() const;
  public:
  void clear_force_encoded_color();
  bool force_encoded_color() const;
  void set_force_encoded_color(bool value);
  private:
  bool _internal_force_encoded_color() const;
  void _internal_set_force_encoded_color(bool value);
  public:

  // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
  bool has_backend() const;
  private:
  bool _internal_has_backend() const;
  public:
  void clear_backend();
  ::opencv_caffe::DataParameter_DB backend() const;
  void set_backend(::opencv_caffe::DataParameter_DB value);
  private:
  ::opencv_caffe::DataParameter_DB _internal_backend() const;
  void _internal_set_backend(::opencv_caffe::DataParameter_DB value);
  public:

  // optional float scale = 2 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // optional uint32 prefetch = 10 [default = 4];
  bool has_prefetch() const;
  private:
  bool _internal_has_prefetch() const;
  public:
  void clear_prefetch();
  uint32_t prefetch() const;
  void set_prefetch(uint32_t value);
  private:
  uint32_t _internal_prefetch() const;
  void _internal_set_prefetch(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.DataParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
    uint32_t batch_size_;
    uint32_t crop_size_;
    uint32_t rand_skip_;
    bool mirror_;
    bool force_encoded_color_;
    int backend_;
    float scale_;
    uint32_t prefetch_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class NonMaximumSuppressionParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NonMaximumSuppressionParameter) */ {
 public:
  inline NonMaximumSuppressionParameter() : NonMaximumSuppressionParameter(nullptr) {}
  ~NonMaximumSuppressionParameter() override;
  explicit PROTOBUF_CONSTEXPR NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline NonMaximumSuppressionParameter& operator=(const NonMaximumSuppressionParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline NonMaximumSuppressionParameter& operator=(NonMaximumSuppressionParameter&& 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 NonMaximumSuppressionParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const NonMaximumSuppressionParameter* internal_default_instance() {
    return reinterpret_cast<const NonMaximumSuppressionParameter*>(
               &_NonMaximumSuppressionParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(NonMaximumSuppressionParameter& a, NonMaximumSuppressionParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(NonMaximumSuppressionParameter* 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(NonMaximumSuppressionParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NonMaximumSuppressionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NonMaximumSuppressionParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NonMaximumSuppressionParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NonMaximumSuppressionParameter& from) {
    NonMaximumSuppressionParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NonMaximumSuppressionParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.NonMaximumSuppressionParameter";
  }
  protected:
  explicit NonMaximumSuppressionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kTopKFieldNumber = 2,
    kNmsThresholdFieldNumber = 1,
    kEtaFieldNumber = 3,
  };
  // optional int32 top_k = 2;
  bool has_top_k() const;
  private:
  bool _internal_has_top_k() const;
  public:
  void clear_top_k();
  int32_t top_k() const;
  void set_top_k(int32_t value);
  private:
  int32_t _internal_top_k() const;
  void _internal_set_top_k(int32_t value);
  public:

  // optional float nms_threshold = 1 [default = 0.3];
  bool has_nms_threshold() const;
  private:
  bool _internal_has_nms_threshold() const;
  public:
  void clear_nms_threshold();
  float nms_threshold() const;
  void set_nms_threshold(float value);
  private:
  float _internal_nms_threshold() const;
  void _internal_set_nms_threshold(float value);
  public:

  // optional float eta = 3 [default = 1];
  bool has_eta() const;
  private:
  bool _internal_has_eta() const;
  public:
  void clear_eta();
  float eta() const;
  void set_eta(float value);
  private:
  float _internal_eta() const;
  void _internal_set_eta(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.NonMaximumSuppressionParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t top_k_;
    float nms_threshold_;
    float eta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SaveOutputParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SaveOutputParameter) */ {
 public:
  inline SaveOutputParameter() : SaveOutputParameter(nullptr) {}
  ~SaveOutputParameter() override;
  explicit PROTOBUF_CONSTEXPR SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SaveOutputParameter& operator=(const SaveOutputParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline SaveOutputParameter& operator=(SaveOutputParameter&& 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 SaveOutputParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const SaveOutputParameter* internal_default_instance() {
    return reinterpret_cast<const SaveOutputParameter*>(
               &_SaveOutputParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(SaveOutputParameter& a, SaveOutputParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(SaveOutputParameter* 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(SaveOutputParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SaveOutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SaveOutputParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SaveOutputParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SaveOutputParameter& from) {
    SaveOutputParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SaveOutputParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SaveOutputParameter";
  }
  protected:
  explicit SaveOutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kOutputDirectoryFieldNumber = 1,
    kOutputNamePrefixFieldNumber = 2,
    kOutputFormatFieldNumber = 3,
    kLabelMapFileFieldNumber = 4,
    kNameSizeFileFieldNumber = 5,
    kNumTestImageFieldNumber = 6,
  };
  // optional string output_directory = 1;
  bool has_output_directory() const;
  private:
  bool _internal_has_output_directory() const;
  public:
  void clear_output_directory();
  const std::string& output_directory() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_directory(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_directory();
  PROTOBUF_NODISCARD std::string* release_output_directory();
  void set_allocated_output_directory(std::string* output_directory);
  private:
  const std::string& _internal_output_directory() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_directory(const std::string& value);
  std::string* _internal_mutable_output_directory();
  public:

  // optional string output_name_prefix = 2;
  bool has_output_name_prefix() const;
  private:
  bool _internal_has_output_name_prefix() const;
  public:
  void clear_output_name_prefix();
  const std::string& output_name_prefix() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_name_prefix(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_name_prefix();
  PROTOBUF_NODISCARD std::string* release_output_name_prefix();
  void set_allocated_output_name_prefix(std::string* output_name_prefix);
  private:
  const std::string& _internal_output_name_prefix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_name_prefix(const std::string& value);
  std::string* _internal_mutable_output_name_prefix();
  public:

  // optional string output_format = 3;
  bool has_output_format() const;
  private:
  bool _internal_has_output_format() const;
  public:
  void clear_output_format();
  const std::string& output_format() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_format(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_format();
  PROTOBUF_NODISCARD std::string* release_output_format();
  void set_allocated_output_format(std::string* output_format);
  private:
  const std::string& _internal_output_format() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_format(const std::string& value);
  std::string* _internal_mutable_output_format();
  public:

  // optional string label_map_file = 4;
  bool has_label_map_file() const;
  private:
  bool _internal_has_label_map_file() const;
  public:
  void clear_label_map_file();
  const std::string& label_map_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_label_map_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_label_map_file();
  PROTOBUF_NODISCARD std::string* release_label_map_file();
  void set_allocated_label_map_file(std::string* label_map_file);
  private:
  const std::string& _internal_label_map_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_label_map_file(const std::string& value);
  std::string* _internal_mutable_label_map_file();
  public:

  // optional string name_size_file = 5;
  bool has_name_size_file() const;
  private:
  bool _internal_has_name_size_file() const;
  public:
  void clear_name_size_file();
  const std::string& name_size_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name_size_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name_size_file();
  PROTOBUF_NODISCARD std::string* release_name_size_file();
  void set_allocated_name_size_file(std::string* name_size_file);
  private:
  const std::string& _internal_name_size_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_size_file(const std::string& value);
  std::string* _internal_mutable_name_size_file();
  public:

  // optional uint32 num_test_image = 6;
  bool has_num_test_image() const;
  private:
  bool _internal_has_num_test_image() const;
  public:
  void clear_num_test_image();
  uint32_t num_test_image() const;
  void set_num_test_image(uint32_t value);
  private:
  uint32_t _internal_num_test_image() const;
  void _internal_set_num_test_image(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SaveOutputParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_directory_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_name_prefix_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_format_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_map_file_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_size_file_;
    uint32_t num_test_image_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class DropoutParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DropoutParameter) */ {
 public:
  inline DropoutParameter() : DropoutParameter(nullptr) {}
  ~DropoutParameter() override;
  explicit PROTOBUF_CONSTEXPR DropoutParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DropoutParameter& operator=(const DropoutParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline DropoutParameter& operator=(DropoutParameter&& 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 DropoutParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const DropoutParameter* internal_default_instance() {
    return reinterpret_cast<const DropoutParameter*>(
               &_DropoutParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(DropoutParameter& a, DropoutParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(DropoutParameter* 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(DropoutParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DropoutParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DropoutParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DropoutParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DropoutParameter& from) {
    DropoutParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DropoutParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.DropoutParameter";
  }
  protected:
  explicit DropoutParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kDropoutRatioFieldNumber = 1,
    kScaleTrainFieldNumber = 2,
  };
  // optional float dropout_ratio = 1 [default = 0.5];
  bool has_dropout_ratio() const;
  private:
  bool _internal_has_dropout_ratio() const;
  public:
  void clear_dropout_ratio();
  float dropout_ratio() const;
  void set_dropout_ratio(float value);
  private:
  float _internal_dropout_ratio() const;
  void _internal_set_dropout_ratio(float value);
  public:

  // optional bool scale_train = 2 [default = true];
  bool has_scale_train() const;
  private:
  bool _internal_has_scale_train() const;
  public:
  void clear_scale_train();
  bool scale_train() const;
  void set_scale_train(bool value);
  private:
  bool _internal_scale_train() const;
  void _internal_set_scale_train(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.DropoutParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float dropout_ratio_;
    bool scale_train_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class DummyDataParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.DummyDataParameter) */ {
 public:
  inline DummyDataParameter() : DummyDataParameter(nullptr) {}
  ~DummyDataParameter() override;
  explicit PROTOBUF_CONSTEXPR DummyDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline DummyDataParameter& operator=(const DummyDataParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline DummyDataParameter& operator=(DummyDataParameter&& 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 DummyDataParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const DummyDataParameter* internal_default_instance() {
    return reinterpret_cast<const DummyDataParameter*>(
               &_DummyDataParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(DummyDataParameter& a, DummyDataParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(DummyDataParameter* 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(DummyDataParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DummyDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DummyDataParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DummyDataParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DummyDataParameter& from) {
    DummyDataParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DummyDataParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.DummyDataParameter";
  }
  protected:
  explicit DummyDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kDataFillerFieldNumber = 1,
    kNumFieldNumber = 2,
    kChannelsFieldNumber = 3,
    kHeightFieldNumber = 4,
    kWidthFieldNumber = 5,
    kShapeFieldNumber = 6,
  };
  // repeated .opencv_caffe.FillerParameter data_filler = 1;
  int data_filler_size() const;
  private:
  int _internal_data_filler_size() const;
  public:
  void clear_data_filler();
  ::opencv_caffe::FillerParameter* mutable_data_filler(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >*
      mutable_data_filler();
  private:
  const ::opencv_caffe::FillerParameter& _internal_data_filler(int index) const;
  ::opencv_caffe::FillerParameter* _internal_add_data_filler();
  public:
  const ::opencv_caffe::FillerParameter& data_filler(int index) const;
  ::opencv_caffe::FillerParameter* add_data_filler();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >&
      data_filler() const;

  // repeated uint32 num = 2;
  int num_size() const;
  private:
  int _internal_num_size() const;
  public:
  void clear_num();
  private:
  uint32_t _internal_num(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_num() const;
  void _internal_add_num(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_num();
  public:
  uint32_t num(int index) const;
  void set_num(int index, uint32_t value);
  void add_num(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      num() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_num();

  // repeated uint32 channels = 3;
  int channels_size() const;
  private:
  int _internal_channels_size() const;
  public:
  void clear_channels();
  private:
  uint32_t _internal_channels(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_channels() const;
  void _internal_add_channels(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_channels();
  public:
  uint32_t channels(int index) const;
  void set_channels(int index, uint32_t value);
  void add_channels(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      channels() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_channels();

  // repeated uint32 height = 4;
  int height_size() const;
  private:
  int _internal_height_size() const;
  public:
  void clear_height();
  private:
  uint32_t _internal_height(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_height() const;
  void _internal_add_height(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_height();
  public:
  uint32_t height(int index) const;
  void set_height(int index, uint32_t value);
  void add_height(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      height() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_height();

  // repeated uint32 width = 5;
  int width_size() const;
  private:
  int _internal_width_size() const;
  public:
  void clear_width();
  private:
  uint32_t _internal_width(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_width() const;
  void _internal_add_width(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_width();
  public:
  uint32_t width(int index) const;
  void set_width(int index, uint32_t value);
  void add_width(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      width() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_width();

  // repeated .opencv_caffe.BlobShape shape = 6;
  int shape_size() const;
  private:
  int _internal_shape_size() const;
  public:
  void clear_shape();
  ::opencv_caffe::BlobShape* mutable_shape(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >*
      mutable_shape();
  private:
  const ::opencv_caffe::BlobShape& _internal_shape(int index) const;
  ::opencv_caffe::BlobShape* _internal_add_shape();
  public:
  const ::opencv_caffe::BlobShape& shape(int index) const;
  ::opencv_caffe::BlobShape* add_shape();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >&
      shape() const;

  // @@protoc_insertion_point(class_scope:opencv_caffe.DummyDataParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter > data_filler_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > num_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > channels_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > height_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > width_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape > shape_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class EltwiseParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.EltwiseParameter) */ {
 public:
  inline EltwiseParameter() : EltwiseParameter(nullptr) {}
  ~EltwiseParameter() override;
  explicit PROTOBUF_CONSTEXPR EltwiseParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EltwiseParameter& operator=(const EltwiseParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline EltwiseParameter& operator=(EltwiseParameter&& 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 EltwiseParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const EltwiseParameter* internal_default_instance() {
    return reinterpret_cast<const EltwiseParameter*>(
               &_EltwiseParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(EltwiseParameter& a, EltwiseParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(EltwiseParameter* 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(EltwiseParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EltwiseParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EltwiseParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EltwiseParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EltwiseParameter& from) {
    EltwiseParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(EltwiseParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.EltwiseParameter";
  }
  protected:
  explicit EltwiseParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 EltwiseParameter_EltwiseOp EltwiseOp;
  static constexpr EltwiseOp PROD =
    EltwiseParameter_EltwiseOp_PROD;
  static constexpr EltwiseOp SUM =
    EltwiseParameter_EltwiseOp_SUM;
  static constexpr EltwiseOp MAX =
    EltwiseParameter_EltwiseOp_MAX;
  static inline bool EltwiseOp_IsValid(int value) {
    return EltwiseParameter_EltwiseOp_IsValid(value);
  }
  static constexpr EltwiseOp EltwiseOp_MIN =
    EltwiseParameter_EltwiseOp_EltwiseOp_MIN;
  static constexpr EltwiseOp EltwiseOp_MAX =
    EltwiseParameter_EltwiseOp_EltwiseOp_MAX;
  static constexpr int EltwiseOp_ARRAYSIZE =
    EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  EltwiseOp_descriptor() {
    return EltwiseParameter_EltwiseOp_descriptor();
  }
  template<typename T>
  static inline const std::string& EltwiseOp_Name(T enum_t_value) {
    static_assert(::std::is_same<T, EltwiseOp>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function EltwiseOp_Name.");
    return EltwiseParameter_EltwiseOp_Name(enum_t_value);
  }
  static inline bool EltwiseOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      EltwiseOp* value) {
    return EltwiseParameter_EltwiseOp_Parse(name, value);
  }

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

  enum : int {
    kCoeffFieldNumber = 2,
    kOperationFieldNumber = 1,
    kStableProdGradFieldNumber = 3,
  };
  // repeated float coeff = 2;
  int coeff_size() const;
  private:
  int _internal_coeff_size() const;
  public:
  void clear_coeff();
  private:
  float _internal_coeff(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_coeff() const;
  void _internal_add_coeff(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_coeff();
  public:
  float coeff(int index) const;
  void set_coeff(int index, float value);
  void add_coeff(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      coeff() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_coeff();

  // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
  bool has_operation() const;
  private:
  bool _internal_has_operation() const;
  public:
  void clear_operation();
  ::opencv_caffe::EltwiseParameter_EltwiseOp operation() const;
  void set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value);
  private:
  ::opencv_caffe::EltwiseParameter_EltwiseOp _internal_operation() const;
  void _internal_set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value);
  public:

  // optional bool stable_prod_grad = 3 [default = true];
  bool has_stable_prod_grad() const;
  private:
  bool _internal_has_stable_prod_grad() const;
  public:
  void clear_stable_prod_grad();
  bool stable_prod_grad() const;
  void set_stable_prod_grad(bool value);
  private:
  bool _internal_stable_prod_grad() const;
  void _internal_set_stable_prod_grad(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.EltwiseParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > coeff_;
    int operation_;
    bool stable_prod_grad_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ELUParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ELUParameter) */ {
 public:
  inline ELUParameter() : ELUParameter(nullptr) {}
  ~ELUParameter() override;
  explicit PROTOBUF_CONSTEXPR ELUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ELUParameter& operator=(const ELUParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ELUParameter& operator=(ELUParameter&& 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 ELUParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ELUParameter* internal_default_instance() {
    return reinterpret_cast<const ELUParameter*>(
               &_ELUParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(ELUParameter& a, ELUParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ELUParameter* 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(ELUParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ELUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ELUParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ELUParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ELUParameter& from) {
    ELUParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ELUParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ELUParameter";
  }
  protected:
  explicit ELUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kAlphaFieldNumber = 1,
  };
  // optional float alpha = 1 [default = 1];
  bool has_alpha() const;
  private:
  bool _internal_has_alpha() const;
  public:
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);
  private:
  float _internal_alpha() const;
  void _internal_set_alpha(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ELUParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float alpha_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class EmbedParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.EmbedParameter) */ {
 public:
  inline EmbedParameter() : EmbedParameter(nullptr) {}
  ~EmbedParameter() override;
  explicit PROTOBUF_CONSTEXPR EmbedParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EmbedParameter& operator=(const EmbedParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline EmbedParameter& operator=(EmbedParameter&& 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 EmbedParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const EmbedParameter* internal_default_instance() {
    return reinterpret_cast<const EmbedParameter*>(
               &_EmbedParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(EmbedParameter& a, EmbedParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(EmbedParameter* 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(EmbedParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EmbedParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EmbedParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EmbedParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EmbedParameter& from) {
    EmbedParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(EmbedParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.EmbedParameter";
  }
  protected:
  explicit EmbedParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kWeightFillerFieldNumber = 4,
    kBiasFillerFieldNumber = 5,
    kNumOutputFieldNumber = 1,
    kInputDimFieldNumber = 2,
    kBiasTermFieldNumber = 3,
  };
  // optional .opencv_caffe.FillerParameter weight_filler = 4;
  bool has_weight_filler() const;
  private:
  bool _internal_has_weight_filler() const;
  public:
  void clear_weight_filler();
  const ::opencv_caffe::FillerParameter& weight_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler();
  ::opencv_caffe::FillerParameter* mutable_weight_filler();
  void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_weight_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler();
  public:
  void unsafe_arena_set_allocated_weight_filler(
      ::opencv_caffe::FillerParameter* weight_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler();

  // optional .opencv_caffe.FillerParameter bias_filler = 5;
  bool has_bias_filler() const;
  private:
  bool _internal_has_bias_filler() const;
  public:
  void clear_bias_filler();
  const ::opencv_caffe::FillerParameter& bias_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler();
  ::opencv_caffe::FillerParameter* mutable_bias_filler();
  void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_bias_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler();
  public:
  void unsafe_arena_set_allocated_bias_filler(
      ::opencv_caffe::FillerParameter* bias_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler();

  // optional uint32 num_output = 1;
  bool has_num_output() const;
  private:
  bool _internal_has_num_output() const;
  public:
  void clear_num_output();
  uint32_t num_output() const;
  void set_num_output(uint32_t value);
  private:
  uint32_t _internal_num_output() const;
  void _internal_set_num_output(uint32_t value);
  public:

  // optional uint32 input_dim = 2;
  bool has_input_dim() const;
  private:
  bool _internal_has_input_dim() const;
  public:
  void clear_input_dim();
  uint32_t input_dim() const;
  void set_input_dim(uint32_t value);
  private:
  uint32_t _internal_input_dim() const;
  void _internal_set_input_dim(uint32_t value);
  public:

  // optional bool bias_term = 3 [default = true];
  bool has_bias_term() const;
  private:
  bool _internal_has_bias_term() const;
  public:
  void clear_bias_term();
  bool bias_term() const;
  void set_bias_term(bool value);
  private:
  bool _internal_bias_term() const;
  void _internal_set_bias_term(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.EmbedParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* weight_filler_;
    ::opencv_caffe::FillerParameter* bias_filler_;
    uint32_t num_output_;
    uint32_t input_dim_;
    bool bias_term_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ExpParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ExpParameter) */ {
 public:
  inline ExpParameter() : ExpParameter(nullptr) {}
  ~ExpParameter() override;
  explicit PROTOBUF_CONSTEXPR ExpParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ExpParameter& operator=(const ExpParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExpParameter& operator=(ExpParameter&& 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 ExpParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExpParameter* internal_default_instance() {
    return reinterpret_cast<const ExpParameter*>(
               &_ExpParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(ExpParameter& a, ExpParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ExpParameter* 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(ExpParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExpParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExpParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExpParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExpParameter& from) {
    ExpParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ExpParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ExpParameter";
  }
  protected:
  explicit ExpParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kShiftFieldNumber = 3,
    kBaseFieldNumber = 1,
    kScaleFieldNumber = 2,
  };
  // optional float shift = 3 [default = 0];
  bool has_shift() const;
  private:
  bool _internal_has_shift() const;
  public:
  void clear_shift();
  float shift() const;
  void set_shift(float value);
  private:
  float _internal_shift() const;
  void _internal_set_shift(float value);
  public:

  // optional float base = 1 [default = -1];
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  float base() const;
  void set_base(float value);
  private:
  float _internal_base() const;
  void _internal_set_base(float value);
  public:

  // optional float scale = 2 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ExpParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float shift_;
    float base_;
    float scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class FlattenParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.FlattenParameter) */ {
 public:
  inline FlattenParameter() : FlattenParameter(nullptr) {}
  ~FlattenParameter() override;
  explicit PROTOBUF_CONSTEXPR FlattenParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline FlattenParameter& operator=(const FlattenParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline FlattenParameter& operator=(FlattenParameter&& 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 FlattenParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const FlattenParameter* internal_default_instance() {
    return reinterpret_cast<const FlattenParameter*>(
               &_FlattenParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(FlattenParameter& a, FlattenParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(FlattenParameter* 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(FlattenParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FlattenParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FlattenParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FlattenParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const FlattenParameter& from) {
    FlattenParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FlattenParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.FlattenParameter";
  }
  protected:
  explicit FlattenParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kAxisFieldNumber = 1,
    kEndAxisFieldNumber = 2,
  };
  // optional int32 axis = 1 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional int32 end_axis = 2 [default = -1];
  bool has_end_axis() const;
  private:
  bool _internal_has_end_axis() const;
  public:
  void clear_end_axis();
  int32_t end_axis() const;
  void set_end_axis(int32_t value);
  private:
  int32_t _internal_end_axis() const;
  void _internal_set_end_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.FlattenParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t axis_;
    int32_t end_axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class HDF5DataParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HDF5DataParameter) */ {
 public:
  inline HDF5DataParameter() : HDF5DataParameter(nullptr) {}
  ~HDF5DataParameter() override;
  explicit PROTOBUF_CONSTEXPR HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HDF5DataParameter& operator=(const HDF5DataParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline HDF5DataParameter& operator=(HDF5DataParameter&& 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 HDF5DataParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const HDF5DataParameter* internal_default_instance() {
    return reinterpret_cast<const HDF5DataParameter*>(
               &_HDF5DataParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(HDF5DataParameter& a, HDF5DataParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(HDF5DataParameter* 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(HDF5DataParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HDF5DataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HDF5DataParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HDF5DataParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HDF5DataParameter& from) {
    HDF5DataParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HDF5DataParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.HDF5DataParameter";
  }
  protected:
  explicit HDF5DataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kSourceFieldNumber = 1,
    kBatchSizeFieldNumber = 2,
    kShuffleFieldNumber = 3,
  };
  // optional string source = 1;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional uint32 batch_size = 2;
  bool has_batch_size() const;
  private:
  bool _internal_has_batch_size() const;
  public:
  void clear_batch_size();
  uint32_t batch_size() const;
  void set_batch_size(uint32_t value);
  private:
  uint32_t _internal_batch_size() const;
  void _internal_set_batch_size(uint32_t value);
  public:

  // optional bool shuffle = 3 [default = false];
  bool has_shuffle() const;
  private:
  bool _internal_has_shuffle() const;
  public:
  void clear_shuffle();
  bool shuffle() const;
  void set_shuffle(bool value);
  private:
  bool _internal_shuffle() const;
  void _internal_set_shuffle(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.HDF5DataParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    uint32_t batch_size_;
    bool shuffle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class HDF5OutputParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HDF5OutputParameter) */ {
 public:
  inline HDF5OutputParameter() : HDF5OutputParameter(nullptr) {}
  ~HDF5OutputParameter() override;
  explicit PROTOBUF_CONSTEXPR HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HDF5OutputParameter& operator=(const HDF5OutputParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline HDF5OutputParameter& operator=(HDF5OutputParameter&& 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 HDF5OutputParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const HDF5OutputParameter* internal_default_instance() {
    return reinterpret_cast<const HDF5OutputParameter*>(
               &_HDF5OutputParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(HDF5OutputParameter& a, HDF5OutputParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(HDF5OutputParameter* 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(HDF5OutputParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HDF5OutputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HDF5OutputParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HDF5OutputParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HDF5OutputParameter& from) {
    HDF5OutputParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HDF5OutputParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.HDF5OutputParameter";
  }
  protected:
  explicit HDF5OutputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kFileNameFieldNumber = 1,
  };
  // optional string file_name = 1;
  bool has_file_name() const;
  private:
  bool _internal_has_file_name() const;
  public:
  void clear_file_name();
  const std::string& file_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_file_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_file_name();
  PROTOBUF_NODISCARD std::string* release_file_name();
  void set_allocated_file_name(std::string* file_name);
  private:
  const std::string& _internal_file_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
  std::string* _internal_mutable_file_name();
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.HDF5OutputParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class HingeLossParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.HingeLossParameter) */ {
 public:
  inline HingeLossParameter() : HingeLossParameter(nullptr) {}
  ~HingeLossParameter() override;
  explicit PROTOBUF_CONSTEXPR HingeLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HingeLossParameter& operator=(const HingeLossParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline HingeLossParameter& operator=(HingeLossParameter&& 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 HingeLossParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const HingeLossParameter* internal_default_instance() {
    return reinterpret_cast<const HingeLossParameter*>(
               &_HingeLossParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(HingeLossParameter& a, HingeLossParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(HingeLossParameter* 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(HingeLossParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HingeLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HingeLossParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HingeLossParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HingeLossParameter& from) {
    HingeLossParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HingeLossParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.HingeLossParameter";
  }
  protected:
  explicit HingeLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 HingeLossParameter_Norm Norm;
  static constexpr Norm L1 =
    HingeLossParameter_Norm_L1;
  static constexpr Norm L2 =
    HingeLossParameter_Norm_L2;
  static inline bool Norm_IsValid(int value) {
    return HingeLossParameter_Norm_IsValid(value);
  }
  static constexpr Norm Norm_MIN =
    HingeLossParameter_Norm_Norm_MIN;
  static constexpr Norm Norm_MAX =
    HingeLossParameter_Norm_Norm_MAX;
  static constexpr int Norm_ARRAYSIZE =
    HingeLossParameter_Norm_Norm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Norm_descriptor() {
    return HingeLossParameter_Norm_descriptor();
  }
  template<typename T>
  static inline const std::string& Norm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Norm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Norm_Name.");
    return HingeLossParameter_Norm_Name(enum_t_value);
  }
  static inline bool Norm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Norm* value) {
    return HingeLossParameter_Norm_Parse(name, value);
  }

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

  enum : int {
    kNormFieldNumber = 1,
  };
  // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
  bool has_norm() const;
  private:
  bool _internal_has_norm() const;
  public:
  void clear_norm();
  ::opencv_caffe::HingeLossParameter_Norm norm() const;
  void set_norm(::opencv_caffe::HingeLossParameter_Norm value);
  private:
  ::opencv_caffe::HingeLossParameter_Norm _internal_norm() const;
  void _internal_set_norm(::opencv_caffe::HingeLossParameter_Norm value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.HingeLossParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int norm_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ImageDataParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ImageDataParameter) */ {
 public:
  inline ImageDataParameter() : ImageDataParameter(nullptr) {}
  ~ImageDataParameter() override;
  explicit PROTOBUF_CONSTEXPR ImageDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ImageDataParameter& operator=(const ImageDataParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ImageDataParameter& operator=(ImageDataParameter&& 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 ImageDataParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ImageDataParameter* internal_default_instance() {
    return reinterpret_cast<const ImageDataParameter*>(
               &_ImageDataParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(ImageDataParameter& a, ImageDataParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ImageDataParameter* 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(ImageDataParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ImageDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImageDataParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ImageDataParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ImageDataParameter& from) {
    ImageDataParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ImageDataParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ImageDataParameter";
  }
  protected:
  explicit ImageDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kSourceFieldNumber = 1,
    kMeanFileFieldNumber = 3,
    kRootFolderFieldNumber = 12,
    kCropSizeFieldNumber = 5,
    kRandSkipFieldNumber = 7,
    kShuffleFieldNumber = 8,
    kMirrorFieldNumber = 6,
    kNewHeightFieldNumber = 9,
    kNewWidthFieldNumber = 10,
    kIsColorFieldNumber = 11,
    kScaleFieldNumber = 2,
    kBatchSizeFieldNumber = 4,
  };
  // optional string source = 1;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional string mean_file = 3;
  bool has_mean_file() const;
  private:
  bool _internal_has_mean_file() const;
  public:
  void clear_mean_file();
  const std::string& mean_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mean_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mean_file();
  PROTOBUF_NODISCARD std::string* release_mean_file();
  void set_allocated_mean_file(std::string* mean_file);
  private:
  const std::string& _internal_mean_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
  std::string* _internal_mutable_mean_file();
  public:

  // optional string root_folder = 12 [default = ""];
  bool has_root_folder() const;
  private:
  bool _internal_has_root_folder() const;
  public:
  void clear_root_folder();
  const std::string& root_folder() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_root_folder(ArgT0&& arg0, ArgT... args);
  std::string* mutable_root_folder();
  PROTOBUF_NODISCARD std::string* release_root_folder();
  void set_allocated_root_folder(std::string* root_folder);
  private:
  const std::string& _internal_root_folder() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_root_folder(const std::string& value);
  std::string* _internal_mutable_root_folder();
  public:

  // optional uint32 crop_size = 5 [default = 0];
  bool has_crop_size() const;
  private:
  bool _internal_has_crop_size() const;
  public:
  void clear_crop_size();
  uint32_t crop_size() const;
  void set_crop_size(uint32_t value);
  private:
  uint32_t _internal_crop_size() const;
  void _internal_set_crop_size(uint32_t value);
  public:

  // optional uint32 rand_skip = 7 [default = 0];
  bool has_rand_skip() const;
  private:
  bool _internal_has_rand_skip() const;
  public:
  void clear_rand_skip();
  uint32_t rand_skip() const;
  void set_rand_skip(uint32_t value);
  private:
  uint32_t _internal_rand_skip() const;
  void _internal_set_rand_skip(uint32_t value);
  public:

  // optional bool shuffle = 8 [default = false];
  bool has_shuffle() const;
  private:
  bool _internal_has_shuffle() const;
  public:
  void clear_shuffle();
  bool shuffle() const;
  void set_shuffle(bool value);
  private:
  bool _internal_shuffle() const;
  void _internal_set_shuffle(bool value);
  public:

  // optional bool mirror = 6 [default = false];
  bool has_mirror() const;
  private:
  bool _internal_has_mirror() const;
  public:
  void clear_mirror();
  bool mirror() const;
  void set_mirror(bool value);
  private:
  bool _internal_mirror() const;
  void _internal_set_mirror(bool value);
  public:

  // optional uint32 new_height = 9 [default = 0];
  bool has_new_height() const;
  private:
  bool _internal_has_new_height() const;
  public:
  void clear_new_height();
  uint32_t new_height() const;
  void set_new_height(uint32_t value);
  private:
  uint32_t _internal_new_height() const;
  void _internal_set_new_height(uint32_t value);
  public:

  // optional uint32 new_width = 10 [default = 0];
  bool has_new_width() const;
  private:
  bool _internal_has_new_width() const;
  public:
  void clear_new_width();
  uint32_t new_width() const;
  void set_new_width(uint32_t value);
  private:
  uint32_t _internal_new_width() const;
  void _internal_set_new_width(uint32_t value);
  public:

  // optional bool is_color = 11 [default = true];
  bool has_is_color() const;
  private:
  bool _internal_has_is_color() const;
  public:
  void clear_is_color();
  bool is_color() const;
  void set_is_color(bool value);
  private:
  bool _internal_is_color() const;
  void _internal_set_is_color(bool value);
  public:

  // optional float scale = 2 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // optional uint32 batch_size = 4 [default = 1];
  bool has_batch_size() const;
  private:
  bool _internal_has_batch_size() const;
  public:
  void clear_batch_size();
  uint32_t batch_size() const;
  void set_batch_size(uint32_t value);
  private:
  uint32_t _internal_batch_size() const;
  void _internal_set_batch_size(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ImageDataParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_folder_;
    uint32_t crop_size_;
    uint32_t rand_skip_;
    bool shuffle_;
    bool mirror_;
    uint32_t new_height_;
    uint32_t new_width_;
    bool is_color_;
    float scale_;
    uint32_t batch_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class InfogainLossParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InfogainLossParameter) */ {
 public:
  inline InfogainLossParameter() : InfogainLossParameter(nullptr) {}
  ~InfogainLossParameter() override;
  explicit PROTOBUF_CONSTEXPR InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InfogainLossParameter& operator=(const InfogainLossParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline InfogainLossParameter& operator=(InfogainLossParameter&& 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 InfogainLossParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const InfogainLossParameter* internal_default_instance() {
    return reinterpret_cast<const InfogainLossParameter*>(
               &_InfogainLossParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(InfogainLossParameter& a, InfogainLossParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(InfogainLossParameter* 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(InfogainLossParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InfogainLossParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InfogainLossParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InfogainLossParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InfogainLossParameter& from) {
    InfogainLossParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InfogainLossParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.InfogainLossParameter";
  }
  protected:
  explicit InfogainLossParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kSourceFieldNumber = 1,
  };
  // optional string source = 1;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.InfogainLossParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class InnerProductParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InnerProductParameter) */ {
 public:
  inline InnerProductParameter() : InnerProductParameter(nullptr) {}
  ~InnerProductParameter() override;
  explicit PROTOBUF_CONSTEXPR InnerProductParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InnerProductParameter& operator=(const InnerProductParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline InnerProductParameter& operator=(InnerProductParameter&& 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 InnerProductParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const InnerProductParameter* internal_default_instance() {
    return reinterpret_cast<const InnerProductParameter*>(
               &_InnerProductParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(InnerProductParameter& a, InnerProductParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(InnerProductParameter* 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(InnerProductParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InnerProductParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InnerProductParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InnerProductParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InnerProductParameter& from) {
    InnerProductParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InnerProductParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.InnerProductParameter";
  }
  protected:
  explicit InnerProductParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kWeightFillerFieldNumber = 3,
    kBiasFillerFieldNumber = 4,
    kNumOutputFieldNumber = 1,
    kTransposeFieldNumber = 6,
    kBiasTermFieldNumber = 2,
    kAxisFieldNumber = 5,
  };
  // optional .opencv_caffe.FillerParameter weight_filler = 3;
  bool has_weight_filler() const;
  private:
  bool _internal_has_weight_filler() const;
  public:
  void clear_weight_filler();
  const ::opencv_caffe::FillerParameter& weight_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler();
  ::opencv_caffe::FillerParameter* mutable_weight_filler();
  void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_weight_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler();
  public:
  void unsafe_arena_set_allocated_weight_filler(
      ::opencv_caffe::FillerParameter* weight_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler();

  // optional .opencv_caffe.FillerParameter bias_filler = 4;
  bool has_bias_filler() const;
  private:
  bool _internal_has_bias_filler() const;
  public:
  void clear_bias_filler();
  const ::opencv_caffe::FillerParameter& bias_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler();
  ::opencv_caffe::FillerParameter* mutable_bias_filler();
  void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_bias_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler();
  public:
  void unsafe_arena_set_allocated_bias_filler(
      ::opencv_caffe::FillerParameter* bias_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler();

  // optional uint32 num_output = 1;
  bool has_num_output() const;
  private:
  bool _internal_has_num_output() const;
  public:
  void clear_num_output();
  uint32_t num_output() const;
  void set_num_output(uint32_t value);
  private:
  uint32_t _internal_num_output() const;
  void _internal_set_num_output(uint32_t value);
  public:

  // optional bool transpose = 6 [default = false];
  bool has_transpose() const;
  private:
  bool _internal_has_transpose() const;
  public:
  void clear_transpose();
  bool transpose() const;
  void set_transpose(bool value);
  private:
  bool _internal_transpose() const;
  void _internal_set_transpose(bool value);
  public:

  // optional bool bias_term = 2 [default = true];
  bool has_bias_term() const;
  private:
  bool _internal_has_bias_term() const;
  public:
  void clear_bias_term();
  bool bias_term() const;
  void set_bias_term(bool value);
  private:
  bool _internal_bias_term() const;
  void _internal_set_bias_term(bool value);
  public:

  // optional int32 axis = 5 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.InnerProductParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* weight_filler_;
    ::opencv_caffe::FillerParameter* bias_filler_;
    uint32_t num_output_;
    bool transpose_;
    bool bias_term_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class InputParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.InputParameter) */ {
 public:
  inline InputParameter() : InputParameter(nullptr) {}
  ~InputParameter() override;
  explicit PROTOBUF_CONSTEXPR InputParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline InputParameter& operator=(const InputParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputParameter& operator=(InputParameter&& 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 InputParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const InputParameter* internal_default_instance() {
    return reinterpret_cast<const InputParameter*>(
               &_InputParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(InputParameter& a, InputParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(InputParameter* 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(InputParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InputParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InputParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InputParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InputParameter& from) {
    InputParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.InputParameter";
  }
  protected:
  explicit InputParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kShapeFieldNumber = 1,
  };
  // repeated .opencv_caffe.BlobShape shape = 1;
  int shape_size() const;
  private:
  int _internal_shape_size() const;
  public:
  void clear_shape();
  ::opencv_caffe::BlobShape* mutable_shape(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >*
      mutable_shape();
  private:
  const ::opencv_caffe::BlobShape& _internal_shape(int index) const;
  ::opencv_caffe::BlobShape* _internal_add_shape();
  public:
  const ::opencv_caffe::BlobShape& shape(int index) const;
  ::opencv_caffe::BlobShape* add_shape();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >&
      shape() const;

  // @@protoc_insertion_point(class_scope:opencv_caffe.InputParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape > shape_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class LogParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LogParameter) */ {
 public:
  inline LogParameter() : LogParameter(nullptr) {}
  ~LogParameter() override;
  explicit PROTOBUF_CONSTEXPR LogParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LogParameter& operator=(const LogParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogParameter& operator=(LogParameter&& 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 LogParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const LogParameter* internal_default_instance() {
    return reinterpret_cast<const LogParameter*>(
               &_LogParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  friend void swap(LogParameter& a, LogParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(LogParameter* 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(LogParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LogParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LogParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LogParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LogParameter& from) {
    LogParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LogParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.LogParameter";
  }
  protected:
  explicit LogParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kShiftFieldNumber = 3,
    kBaseFieldNumber = 1,
    kScaleFieldNumber = 2,
  };
  // optional float shift = 3 [default = 0];
  bool has_shift() const;
  private:
  bool _internal_has_shift() const;
  public:
  void clear_shift();
  float shift() const;
  void set_shift(float value);
  private:
  float _internal_shift() const;
  void _internal_set_shift(float value);
  public:

  // optional float base = 1 [default = -1];
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  float base() const;
  void set_base(float value);
  private:
  float _internal_base() const;
  void _internal_set_base(float value);
  public:

  // optional float scale = 2 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.LogParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float shift_;
    float base_;
    float scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class LRNParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.LRNParameter) */ {
 public:
  inline LRNParameter() : LRNParameter(nullptr) {}
  ~LRNParameter() override;
  explicit PROTOBUF_CONSTEXPR LRNParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LRNParameter& operator=(const LRNParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline LRNParameter& operator=(LRNParameter&& 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 LRNParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const LRNParameter* internal_default_instance() {
    return reinterpret_cast<const LRNParameter*>(
               &_LRNParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  friend void swap(LRNParameter& a, LRNParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(LRNParameter* 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(LRNParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LRNParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LRNParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LRNParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LRNParameter& from) {
    LRNParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LRNParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.LRNParameter";
  }
  protected:
  explicit LRNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 LRNParameter_NormRegion NormRegion;
  static constexpr NormRegion ACROSS_CHANNELS =
    LRNParameter_NormRegion_ACROSS_CHANNELS;
  static constexpr NormRegion WITHIN_CHANNEL =
    LRNParameter_NormRegion_WITHIN_CHANNEL;
  static inline bool NormRegion_IsValid(int value) {
    return LRNParameter_NormRegion_IsValid(value);
  }
  static constexpr NormRegion NormRegion_MIN =
    LRNParameter_NormRegion_NormRegion_MIN;
  static constexpr NormRegion NormRegion_MAX =
    LRNParameter_NormRegion_NormRegion_MAX;
  static constexpr int NormRegion_ARRAYSIZE =
    LRNParameter_NormRegion_NormRegion_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  NormRegion_descriptor() {
    return LRNParameter_NormRegion_descriptor();
  }
  template<typename T>
  static inline const std::string& NormRegion_Name(T enum_t_value) {
    static_assert(::std::is_same<T, NormRegion>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function NormRegion_Name.");
    return LRNParameter_NormRegion_Name(enum_t_value);
  }
  static inline bool NormRegion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      NormRegion* value) {
    return LRNParameter_NormRegion_Parse(name, value);
  }

  typedef LRNParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    LRNParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    LRNParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    LRNParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return LRNParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    LRNParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    LRNParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    LRNParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return LRNParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return LRNParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return LRNParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kNormRegionFieldNumber = 4,
    kEngineFieldNumber = 6,
    kLocalSizeFieldNumber = 1,
    kAlphaFieldNumber = 2,
    kBetaFieldNumber = 3,
    kKFieldNumber = 5,
  };
  // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
  bool has_norm_region() const;
  private:
  bool _internal_has_norm_region() const;
  public:
  void clear_norm_region();
  ::opencv_caffe::LRNParameter_NormRegion norm_region() const;
  void set_norm_region(::opencv_caffe::LRNParameter_NormRegion value);
  private:
  ::opencv_caffe::LRNParameter_NormRegion _internal_norm_region() const;
  void _internal_set_norm_region(::opencv_caffe::LRNParameter_NormRegion value);
  public:

  // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::LRNParameter_Engine engine() const;
  void set_engine(::opencv_caffe::LRNParameter_Engine value);
  private:
  ::opencv_caffe::LRNParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::LRNParameter_Engine value);
  public:

  // optional uint32 local_size = 1 [default = 5];
  bool has_local_size() const;
  private:
  bool _internal_has_local_size() const;
  public:
  void clear_local_size();
  uint32_t local_size() const;
  void set_local_size(uint32_t value);
  private:
  uint32_t _internal_local_size() const;
  void _internal_set_local_size(uint32_t value);
  public:

  // optional float alpha = 2 [default = 1];
  bool has_alpha() const;
  private:
  bool _internal_has_alpha() const;
  public:
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);
  private:
  float _internal_alpha() const;
  void _internal_set_alpha(float value);
  public:

  // optional float beta = 3 [default = 0.75];
  bool has_beta() const;
  private:
  bool _internal_has_beta() const;
  public:
  void clear_beta();
  float beta() const;
  void set_beta(float value);
  private:
  float _internal_beta() const;
  void _internal_set_beta(float value);
  public:

  // optional float k = 5 [default = 1];
  bool has_k() const;
  private:
  bool _internal_has_k() const;
  public:
  void clear_k();
  float k() const;
  void set_k(float value);
  private:
  float _internal_k() const;
  void _internal_set_k(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.LRNParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int norm_region_;
    int engine_;
    uint32_t local_size_;
    float alpha_;
    float beta_;
    float k_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class MemoryDataParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.MemoryDataParameter) */ {
 public:
  inline MemoryDataParameter() : MemoryDataParameter(nullptr) {}
  ~MemoryDataParameter() override;
  explicit PROTOBUF_CONSTEXPR MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline MemoryDataParameter& operator=(const MemoryDataParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline MemoryDataParameter& operator=(MemoryDataParameter&& 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 MemoryDataParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const MemoryDataParameter* internal_default_instance() {
    return reinterpret_cast<const MemoryDataParameter*>(
               &_MemoryDataParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  friend void swap(MemoryDataParameter& a, MemoryDataParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(MemoryDataParameter* 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(MemoryDataParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MemoryDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MemoryDataParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MemoryDataParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MemoryDataParameter& from) {
    MemoryDataParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MemoryDataParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.MemoryDataParameter";
  }
  protected:
  explicit MemoryDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kBatchSizeFieldNumber = 1,
    kChannelsFieldNumber = 2,
    kHeightFieldNumber = 3,
    kWidthFieldNumber = 4,
  };
  // optional uint32 batch_size = 1;
  bool has_batch_size() const;
  private:
  bool _internal_has_batch_size() const;
  public:
  void clear_batch_size();
  uint32_t batch_size() const;
  void set_batch_size(uint32_t value);
  private:
  uint32_t _internal_batch_size() const;
  void _internal_set_batch_size(uint32_t value);
  public:

  // optional uint32 channels = 2;
  bool has_channels() const;
  private:
  bool _internal_has_channels() const;
  public:
  void clear_channels();
  uint32_t channels() const;
  void set_channels(uint32_t value);
  private:
  uint32_t _internal_channels() const;
  void _internal_set_channels(uint32_t value);
  public:

  // optional uint32 height = 3;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  uint32_t height() const;
  void set_height(uint32_t value);
  private:
  uint32_t _internal_height() const;
  void _internal_set_height(uint32_t value);
  public:

  // optional uint32 width = 4;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  uint32_t width() const;
  void set_width(uint32_t value);
  private:
  uint32_t _internal_width() const;
  void _internal_set_width(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.MemoryDataParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t batch_size_;
    uint32_t channels_;
    uint32_t height_;
    uint32_t width_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class MVNParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.MVNParameter) */ {
 public:
  inline MVNParameter() : MVNParameter(nullptr) {}
  ~MVNParameter() override;
  explicit PROTOBUF_CONSTEXPR MVNParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline MVNParameter& operator=(const MVNParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline MVNParameter& operator=(MVNParameter&& 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 MVNParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const MVNParameter* internal_default_instance() {
    return reinterpret_cast<const MVNParameter*>(
               &_MVNParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(MVNParameter& a, MVNParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(MVNParameter* 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(MVNParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MVNParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MVNParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MVNParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MVNParameter& from) {
    MVNParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MVNParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.MVNParameter";
  }
  protected:
  explicit MVNParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kAcrossChannelsFieldNumber = 2,
    kNormalizeVarianceFieldNumber = 1,
    kEpsFieldNumber = 3,
  };
  // optional bool across_channels = 2 [default = false];
  bool has_across_channels() const;
  private:
  bool _internal_has_across_channels() const;
  public:
  void clear_across_channels();
  bool across_channels() const;
  void set_across_channels(bool value);
  private:
  bool _internal_across_channels() const;
  void _internal_set_across_channels(bool value);
  public:

  // optional bool normalize_variance = 1 [default = true];
  bool has_normalize_variance() const;
  private:
  bool _internal_has_normalize_variance() const;
  public:
  void clear_normalize_variance();
  bool normalize_variance() const;
  void set_normalize_variance(bool value);
  private:
  bool _internal_normalize_variance() const;
  void _internal_set_normalize_variance(bool value);
  public:

  // optional float eps = 3 [default = 1e-09];
  bool has_eps() const;
  private:
  bool _internal_has_eps() const;
  public:
  void clear_eps();
  float eps() const;
  void set_eps(float value);
  private:
  float _internal_eps() const;
  void _internal_set_eps(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.MVNParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool across_channels_;
    bool normalize_variance_;
    float eps_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ParameterParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ParameterParameter) */ {
 public:
  inline ParameterParameter() : ParameterParameter(nullptr) {}
  ~ParameterParameter() override;
  explicit PROTOBUF_CONSTEXPR ParameterParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ParameterParameter& operator=(const ParameterParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ParameterParameter& operator=(ParameterParameter&& 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 ParameterParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ParameterParameter* internal_default_instance() {
    return reinterpret_cast<const ParameterParameter*>(
               &_ParameterParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  friend void swap(ParameterParameter& a, ParameterParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ParameterParameter* 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(ParameterParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ParameterParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ParameterParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ParameterParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ParameterParameter& from) {
    ParameterParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ParameterParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ParameterParameter";
  }
  protected:
  explicit ParameterParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kShapeFieldNumber = 1,
  };
  // optional .opencv_caffe.BlobShape shape = 1;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::opencv_caffe::BlobShape& shape() const;
  PROTOBUF_NODISCARD ::opencv_caffe::BlobShape* release_shape();
  ::opencv_caffe::BlobShape* mutable_shape();
  void set_allocated_shape(::opencv_caffe::BlobShape* shape);
  private:
  const ::opencv_caffe::BlobShape& _internal_shape() const;
  ::opencv_caffe::BlobShape* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::opencv_caffe::BlobShape* shape);
  ::opencv_caffe::BlobShape* unsafe_arena_release_shape();

  // @@protoc_insertion_point(class_scope:opencv_caffe.ParameterParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::BlobShape* shape_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PoolingParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PoolingParameter) */ {
 public:
  inline PoolingParameter() : PoolingParameter(nullptr) {}
  ~PoolingParameter() override;
  explicit PROTOBUF_CONSTEXPR PoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PoolingParameter& operator=(const PoolingParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PoolingParameter& operator=(PoolingParameter&& 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 PoolingParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PoolingParameter* internal_default_instance() {
    return reinterpret_cast<const PoolingParameter*>(
               &_PoolingParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  friend void swap(PoolingParameter& a, PoolingParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PoolingParameter* 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(PoolingParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PoolingParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PoolingParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PoolingParameter& from) {
    PoolingParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PoolingParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PoolingParameter";
  }
  protected:
  explicit PoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 PoolingParameter_PoolMethod PoolMethod;
  static constexpr PoolMethod MAX =
    PoolingParameter_PoolMethod_MAX;
  static constexpr PoolMethod AVE =
    PoolingParameter_PoolMethod_AVE;
  static constexpr PoolMethod STOCHASTIC =
    PoolingParameter_PoolMethod_STOCHASTIC;
  static inline bool PoolMethod_IsValid(int value) {
    return PoolingParameter_PoolMethod_IsValid(value);
  }
  static constexpr PoolMethod PoolMethod_MIN =
    PoolingParameter_PoolMethod_PoolMethod_MIN;
  static constexpr PoolMethod PoolMethod_MAX =
    PoolingParameter_PoolMethod_PoolMethod_MAX;
  static constexpr int PoolMethod_ARRAYSIZE =
    PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PoolMethod_descriptor() {
    return PoolingParameter_PoolMethod_descriptor();
  }
  template<typename T>
  static inline const std::string& PoolMethod_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PoolMethod>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PoolMethod_Name.");
    return PoolingParameter_PoolMethod_Name(enum_t_value);
  }
  static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PoolMethod* value) {
    return PoolingParameter_PoolMethod_Parse(name, value);
  }

  typedef PoolingParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    PoolingParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    PoolingParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    PoolingParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return PoolingParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    PoolingParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    PoolingParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    PoolingParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return PoolingParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return PoolingParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return PoolingParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kPoolFieldNumber = 1,
    kKernelSizeFieldNumber = 2,
    kPadFieldNumber = 4,
    kKernelHFieldNumber = 5,
    kKernelWFieldNumber = 6,
    kStrideHFieldNumber = 7,
    kStrideWFieldNumber = 8,
    kPadHFieldNumber = 9,
    kPadWFieldNumber = 10,
    kEngineFieldNumber = 11,
    kGlobalPoolingFieldNumber = 12,
    kStrideFieldNumber = 3,
    kCeilModeFieldNumber = 13,
  };
  // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
  bool has_pool() const;
  private:
  bool _internal_has_pool() const;
  public:
  void clear_pool();
  ::opencv_caffe::PoolingParameter_PoolMethod pool() const;
  void set_pool(::opencv_caffe::PoolingParameter_PoolMethod value);
  private:
  ::opencv_caffe::PoolingParameter_PoolMethod _internal_pool() const;
  void _internal_set_pool(::opencv_caffe::PoolingParameter_PoolMethod value);
  public:

  // optional uint32 kernel_size = 2;
  bool has_kernel_size() const;
  private:
  bool _internal_has_kernel_size() const;
  public:
  void clear_kernel_size();
  uint32_t kernel_size() const;
  void set_kernel_size(uint32_t value);
  private:
  uint32_t _internal_kernel_size() const;
  void _internal_set_kernel_size(uint32_t value);
  public:

  // optional uint32 pad = 4 [default = 0];
  bool has_pad() const;
  private:
  bool _internal_has_pad() const;
  public:
  void clear_pad();
  uint32_t pad() const;
  void set_pad(uint32_t value);
  private:
  uint32_t _internal_pad() const;
  void _internal_set_pad(uint32_t value);
  public:

  // optional uint32 kernel_h = 5;
  bool has_kernel_h() const;
  private:
  bool _internal_has_kernel_h() const;
  public:
  void clear_kernel_h();
  uint32_t kernel_h() const;
  void set_kernel_h(uint32_t value);
  private:
  uint32_t _internal_kernel_h() const;
  void _internal_set_kernel_h(uint32_t value);
  public:

  // optional uint32 kernel_w = 6;
  bool has_kernel_w() const;
  private:
  bool _internal_has_kernel_w() const;
  public:
  void clear_kernel_w();
  uint32_t kernel_w() const;
  void set_kernel_w(uint32_t value);
  private:
  uint32_t _internal_kernel_w() const;
  void _internal_set_kernel_w(uint32_t value);
  public:

  // optional uint32 stride_h = 7;
  bool has_stride_h() const;
  private:
  bool _internal_has_stride_h() const;
  public:
  void clear_stride_h();
  uint32_t stride_h() const;
  void set_stride_h(uint32_t value);
  private:
  uint32_t _internal_stride_h() const;
  void _internal_set_stride_h(uint32_t value);
  public:

  // optional uint32 stride_w = 8;
  bool has_stride_w() const;
  private:
  bool _internal_has_stride_w() const;
  public:
  void clear_stride_w();
  uint32_t stride_w() const;
  void set_stride_w(uint32_t value);
  private:
  uint32_t _internal_stride_w() const;
  void _internal_set_stride_w(uint32_t value);
  public:

  // optional uint32 pad_h = 9 [default = 0];
  bool has_pad_h() const;
  private:
  bool _internal_has_pad_h() const;
  public:
  void clear_pad_h();
  uint32_t pad_h() const;
  void set_pad_h(uint32_t value);
  private:
  uint32_t _internal_pad_h() const;
  void _internal_set_pad_h(uint32_t value);
  public:

  // optional uint32 pad_w = 10 [default = 0];
  bool has_pad_w() const;
  private:
  bool _internal_has_pad_w() const;
  public:
  void clear_pad_w();
  uint32_t pad_w() const;
  void set_pad_w(uint32_t value);
  private:
  uint32_t _internal_pad_w() const;
  void _internal_set_pad_w(uint32_t value);
  public:

  // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::PoolingParameter_Engine engine() const;
  void set_engine(::opencv_caffe::PoolingParameter_Engine value);
  private:
  ::opencv_caffe::PoolingParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::PoolingParameter_Engine value);
  public:

  // optional bool global_pooling = 12 [default = false];
  bool has_global_pooling() const;
  private:
  bool _internal_has_global_pooling() const;
  public:
  void clear_global_pooling();
  bool global_pooling() const;
  void set_global_pooling(bool value);
  private:
  bool _internal_global_pooling() const;
  void _internal_set_global_pooling(bool value);
  public:

  // optional uint32 stride = 3 [default = 1];
  bool has_stride() const;
  private:
  bool _internal_has_stride() const;
  public:
  void clear_stride();
  uint32_t stride() const;
  void set_stride(uint32_t value);
  private:
  uint32_t _internal_stride() const;
  void _internal_set_stride(uint32_t value);
  public:

  // optional bool ceil_mode = 13 [default = true];
  bool has_ceil_mode() const;
  private:
  bool _internal_has_ceil_mode() const;
  public:
  void clear_ceil_mode();
  bool ceil_mode() const;
  void set_ceil_mode(bool value);
  private:
  bool _internal_ceil_mode() const;
  void _internal_set_ceil_mode(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.PoolingParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int pool_;
    uint32_t kernel_size_;
    uint32_t pad_;
    uint32_t kernel_h_;
    uint32_t kernel_w_;
    uint32_t stride_h_;
    uint32_t stride_w_;
    uint32_t pad_h_;
    uint32_t pad_w_;
    int engine_;
    bool global_pooling_;
    uint32_t stride_;
    bool ceil_mode_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PowerParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PowerParameter) */ {
 public:
  inline PowerParameter() : PowerParameter(nullptr) {}
  ~PowerParameter() override;
  explicit PROTOBUF_CONSTEXPR PowerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PowerParameter& operator=(const PowerParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PowerParameter& operator=(PowerParameter&& 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 PowerParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PowerParameter* internal_default_instance() {
    return reinterpret_cast<const PowerParameter*>(
               &_PowerParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  friend void swap(PowerParameter& a, PowerParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PowerParameter* 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(PowerParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PowerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PowerParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PowerParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PowerParameter& from) {
    PowerParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PowerParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PowerParameter";
  }
  protected:
  explicit PowerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kShiftFieldNumber = 3,
    kPowerFieldNumber = 1,
    kScaleFieldNumber = 2,
  };
  // optional float shift = 3 [default = 0];
  bool has_shift() const;
  private:
  bool _internal_has_shift() const;
  public:
  void clear_shift();
  float shift() const;
  void set_shift(float value);
  private:
  float _internal_shift() const;
  void _internal_set_shift(float value);
  public:

  // optional float power = 1 [default = 1];
  bool has_power() const;
  private:
  bool _internal_has_power() const;
  public:
  void clear_power();
  float power() const;
  void set_power(float value);
  private:
  float _internal_power() const;
  void _internal_set_power(float value);
  public:

  // optional float scale = 2 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.PowerParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float shift_;
    float power_;
    float scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PythonParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PythonParameter) */ {
 public:
  inline PythonParameter() : PythonParameter(nullptr) {}
  ~PythonParameter() override;
  explicit PROTOBUF_CONSTEXPR PythonParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PythonParameter& operator=(const PythonParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PythonParameter& operator=(PythonParameter&& 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 PythonParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PythonParameter* internal_default_instance() {
    return reinterpret_cast<const PythonParameter*>(
               &_PythonParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  friend void swap(PythonParameter& a, PythonParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PythonParameter* 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(PythonParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PythonParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PythonParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PythonParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PythonParameter& from) {
    PythonParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PythonParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PythonParameter";
  }
  protected:
  explicit PythonParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kModuleFieldNumber = 1,
    kLayerFieldNumber = 2,
    kParamStrFieldNumber = 3,
    kShareInParallelFieldNumber = 4,
  };
  // optional string module = 1;
  bool has_module() const;
  private:
  bool _internal_has_module() const;
  public:
  void clear_module();
  const std::string& module() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_module(ArgT0&& arg0, ArgT... args);
  std::string* mutable_module();
  PROTOBUF_NODISCARD std::string* release_module();
  void set_allocated_module(std::string* module);
  private:
  const std::string& _internal_module() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_module(const std::string& value);
  std::string* _internal_mutable_module();
  public:

  // optional string layer = 2;
  bool has_layer() const;
  private:
  bool _internal_has_layer() const;
  public:
  void clear_layer();
  const std::string& layer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_layer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_layer();
  PROTOBUF_NODISCARD std::string* release_layer();
  void set_allocated_layer(std::string* layer);
  private:
  const std::string& _internal_layer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_layer(const std::string& value);
  std::string* _internal_mutable_layer();
  public:

  // optional string param_str = 3 [default = ""];
  bool has_param_str() const;
  private:
  bool _internal_has_param_str() const;
  public:
  void clear_param_str();
  const std::string& param_str() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param_str(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param_str();
  PROTOBUF_NODISCARD std::string* release_param_str();
  void set_allocated_param_str(std::string* param_str);
  private:
  const std::string& _internal_param_str() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param_str(const std::string& value);
  std::string* _internal_mutable_param_str();
  public:

  // optional bool share_in_parallel = 4 [default = false];
  bool has_share_in_parallel() const;
  private:
  bool _internal_has_share_in_parallel() const;
  public:
  void clear_share_in_parallel();
  bool share_in_parallel() const;
  void set_share_in_parallel(bool value);
  private:
  bool _internal_share_in_parallel() const;
  void _internal_set_share_in_parallel(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.PythonParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr module_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr layer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_str_;
    bool share_in_parallel_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class RecurrentParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.RecurrentParameter) */ {
 public:
  inline RecurrentParameter() : RecurrentParameter(nullptr) {}
  ~RecurrentParameter() override;
  explicit PROTOBUF_CONSTEXPR RecurrentParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RecurrentParameter& operator=(const RecurrentParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline RecurrentParameter& operator=(RecurrentParameter&& 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 RecurrentParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const RecurrentParameter* internal_default_instance() {
    return reinterpret_cast<const RecurrentParameter*>(
               &_RecurrentParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(RecurrentParameter& a, RecurrentParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(RecurrentParameter* 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(RecurrentParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RecurrentParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RecurrentParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RecurrentParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RecurrentParameter& from) {
    RecurrentParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RecurrentParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.RecurrentParameter";
  }
  protected:
  explicit RecurrentParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kWeightFillerFieldNumber = 2,
    kBiasFillerFieldNumber = 3,
    kNumOutputFieldNumber = 1,
    kDebugInfoFieldNumber = 4,
    kExposeHiddenFieldNumber = 5,
  };
  // optional .opencv_caffe.FillerParameter weight_filler = 2;
  bool has_weight_filler() const;
  private:
  bool _internal_has_weight_filler() const;
  public:
  void clear_weight_filler();
  const ::opencv_caffe::FillerParameter& weight_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler();
  ::opencv_caffe::FillerParameter* mutable_weight_filler();
  void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_weight_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler();
  public:
  void unsafe_arena_set_allocated_weight_filler(
      ::opencv_caffe::FillerParameter* weight_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler();

  // optional .opencv_caffe.FillerParameter bias_filler = 3;
  bool has_bias_filler() const;
  private:
  bool _internal_has_bias_filler() const;
  public:
  void clear_bias_filler();
  const ::opencv_caffe::FillerParameter& bias_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler();
  ::opencv_caffe::FillerParameter* mutable_bias_filler();
  void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_bias_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler();
  public:
  void unsafe_arena_set_allocated_bias_filler(
      ::opencv_caffe::FillerParameter* bias_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler();

  // optional uint32 num_output = 1 [default = 0];
  bool has_num_output() const;
  private:
  bool _internal_has_num_output() const;
  public:
  void clear_num_output();
  uint32_t num_output() const;
  void set_num_output(uint32_t value);
  private:
  uint32_t _internal_num_output() const;
  void _internal_set_num_output(uint32_t value);
  public:

  // optional bool debug_info = 4 [default = false];
  bool has_debug_info() const;
  private:
  bool _internal_has_debug_info() const;
  public:
  void clear_debug_info();
  bool debug_info() const;
  void set_debug_info(bool value);
  private:
  bool _internal_debug_info() const;
  void _internal_set_debug_info(bool value);
  public:

  // optional bool expose_hidden = 5 [default = false];
  bool has_expose_hidden() const;
  private:
  bool _internal_has_expose_hidden() const;
  public:
  void clear_expose_hidden();
  bool expose_hidden() const;
  void set_expose_hidden(bool value);
  private:
  bool _internal_expose_hidden() const;
  void _internal_set_expose_hidden(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.RecurrentParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* weight_filler_;
    ::opencv_caffe::FillerParameter* bias_filler_;
    uint32_t num_output_;
    bool debug_info_;
    bool expose_hidden_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ReductionParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReductionParameter) */ {
 public:
  inline ReductionParameter() : ReductionParameter(nullptr) {}
  ~ReductionParameter() override;
  explicit PROTOBUF_CONSTEXPR ReductionParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ReductionParameter& operator=(const ReductionParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReductionParameter& operator=(ReductionParameter&& 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 ReductionParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReductionParameter* internal_default_instance() {
    return reinterpret_cast<const ReductionParameter*>(
               &_ReductionParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(ReductionParameter& a, ReductionParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ReductionParameter* 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(ReductionParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReductionParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReductionParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReductionParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ReductionParameter& from) {
    ReductionParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReductionParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ReductionParameter";
  }
  protected:
  explicit ReductionParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 ReductionParameter_ReductionOp ReductionOp;
  static constexpr ReductionOp SUM =
    ReductionParameter_ReductionOp_SUM;
  static constexpr ReductionOp ASUM =
    ReductionParameter_ReductionOp_ASUM;
  static constexpr ReductionOp SUMSQ =
    ReductionParameter_ReductionOp_SUMSQ;
  static constexpr ReductionOp MEAN =
    ReductionParameter_ReductionOp_MEAN;
  static inline bool ReductionOp_IsValid(int value) {
    return ReductionParameter_ReductionOp_IsValid(value);
  }
  static constexpr ReductionOp ReductionOp_MIN =
    ReductionParameter_ReductionOp_ReductionOp_MIN;
  static constexpr ReductionOp ReductionOp_MAX =
    ReductionParameter_ReductionOp_ReductionOp_MAX;
  static constexpr int ReductionOp_ARRAYSIZE =
    ReductionParameter_ReductionOp_ReductionOp_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ReductionOp_descriptor() {
    return ReductionParameter_ReductionOp_descriptor();
  }
  template<typename T>
  static inline const std::string& ReductionOp_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ReductionOp>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ReductionOp_Name.");
    return ReductionParameter_ReductionOp_Name(enum_t_value);
  }
  static inline bool ReductionOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ReductionOp* value) {
    return ReductionParameter_ReductionOp_Parse(name, value);
  }

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

  enum : int {
    kAxisFieldNumber = 2,
    kOperationFieldNumber = 1,
    kCoeffFieldNumber = 3,
  };
  // optional int32 axis = 2 [default = 0];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
  bool has_operation() const;
  private:
  bool _internal_has_operation() const;
  public:
  void clear_operation();
  ::opencv_caffe::ReductionParameter_ReductionOp operation() const;
  void set_operation(::opencv_caffe::ReductionParameter_ReductionOp value);
  private:
  ::opencv_caffe::ReductionParameter_ReductionOp _internal_operation() const;
  void _internal_set_operation(::opencv_caffe::ReductionParameter_ReductionOp value);
  public:

  // optional float coeff = 3 [default = 1];
  bool has_coeff() const;
  private:
  bool _internal_has_coeff() const;
  public:
  void clear_coeff();
  float coeff() const;
  void set_coeff(float value);
  private:
  float _internal_coeff() const;
  void _internal_set_coeff(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ReductionParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t axis_;
    int operation_;
    float coeff_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ReLUParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReLUParameter) */ {
 public:
  inline ReLUParameter() : ReLUParameter(nullptr) {}
  ~ReLUParameter() override;
  explicit PROTOBUF_CONSTEXPR ReLUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ReLUParameter& operator=(const ReLUParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReLUParameter& operator=(ReLUParameter&& 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 ReLUParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReLUParameter* internal_default_instance() {
    return reinterpret_cast<const ReLUParameter*>(
               &_ReLUParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(ReLUParameter& a, ReLUParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ReLUParameter* 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(ReLUParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReLUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReLUParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReLUParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ReLUParameter& from) {
    ReLUParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReLUParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ReLUParameter";
  }
  protected:
  explicit ReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 ReLUParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    ReLUParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    ReLUParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    ReLUParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return ReLUParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    ReLUParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    ReLUParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    ReLUParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return ReLUParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return ReLUParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return ReLUParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kNegativeSlopeFieldNumber = 1,
    kEngineFieldNumber = 2,
  };
  // optional float negative_slope = 1 [default = 0];
  bool has_negative_slope() const;
  private:
  bool _internal_has_negative_slope() const;
  public:
  void clear_negative_slope();
  float negative_slope() const;
  void set_negative_slope(float value);
  private:
  float _internal_negative_slope() const;
  void _internal_set_negative_slope(float value);
  public:

  // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::ReLUParameter_Engine engine() const;
  void set_engine(::opencv_caffe::ReLUParameter_Engine value);
  private:
  ::opencv_caffe::ReLUParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::ReLUParameter_Engine value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ReLUParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float negative_slope_;
    int engine_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ReshapeParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ReshapeParameter) */ {
 public:
  inline ReshapeParameter() : ReshapeParameter(nullptr) {}
  ~ReshapeParameter() override;
  explicit PROTOBUF_CONSTEXPR ReshapeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ReshapeParameter& operator=(const ReshapeParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReshapeParameter& operator=(ReshapeParameter&& 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 ReshapeParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReshapeParameter* internal_default_instance() {
    return reinterpret_cast<const ReshapeParameter*>(
               &_ReshapeParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(ReshapeParameter& a, ReshapeParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ReshapeParameter* 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(ReshapeParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReshapeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReshapeParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReshapeParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ReshapeParameter& from) {
    ReshapeParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReshapeParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ReshapeParameter";
  }
  protected:
  explicit ReshapeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kShapeFieldNumber = 1,
    kAxisFieldNumber = 2,
    kNumAxesFieldNumber = 3,
  };
  // optional .opencv_caffe.BlobShape shape = 1;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::opencv_caffe::BlobShape& shape() const;
  PROTOBUF_NODISCARD ::opencv_caffe::BlobShape* release_shape();
  ::opencv_caffe::BlobShape* mutable_shape();
  void set_allocated_shape(::opencv_caffe::BlobShape* shape);
  private:
  const ::opencv_caffe::BlobShape& _internal_shape() const;
  ::opencv_caffe::BlobShape* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::opencv_caffe::BlobShape* shape);
  ::opencv_caffe::BlobShape* unsafe_arena_release_shape();

  // optional int32 axis = 2 [default = 0];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional int32 num_axes = 3 [default = -1];
  bool has_num_axes() const;
  private:
  bool _internal_has_num_axes() const;
  public:
  void clear_num_axes();
  int32_t num_axes() const;
  void set_num_axes(int32_t value);
  private:
  int32_t _internal_num_axes() const;
  void _internal_set_num_axes(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ReshapeParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::BlobShape* shape_;
    int32_t axis_;
    int32_t num_axes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ScaleParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ScaleParameter) */ {
 public:
  inline ScaleParameter() : ScaleParameter(nullptr) {}
  ~ScaleParameter() override;
  explicit PROTOBUF_CONSTEXPR ScaleParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ScaleParameter& operator=(const ScaleParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScaleParameter& operator=(ScaleParameter&& 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 ScaleParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ScaleParameter* internal_default_instance() {
    return reinterpret_cast<const ScaleParameter*>(
               &_ScaleParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  friend void swap(ScaleParameter& a, ScaleParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ScaleParameter* 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(ScaleParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ScaleParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ScaleParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ScaleParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ScaleParameter& from) {
    ScaleParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ScaleParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ScaleParameter";
  }
  protected:
  explicit ScaleParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kFillerFieldNumber = 3,
    kBiasFillerFieldNumber = 5,
    kBiasTermFieldNumber = 4,
    kAxisFieldNumber = 1,
    kNumAxesFieldNumber = 2,
  };
  // optional .opencv_caffe.FillerParameter filler = 3;
  bool has_filler() const;
  private:
  bool _internal_has_filler() const;
  public:
  void clear_filler();
  const ::opencv_caffe::FillerParameter& filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_filler();
  ::opencv_caffe::FillerParameter* mutable_filler();
  void set_allocated_filler(::opencv_caffe::FillerParameter* filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_filler();
  public:
  void unsafe_arena_set_allocated_filler(
      ::opencv_caffe::FillerParameter* filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_filler();

  // optional .opencv_caffe.FillerParameter bias_filler = 5;
  bool has_bias_filler() const;
  private:
  bool _internal_has_bias_filler() const;
  public:
  void clear_bias_filler();
  const ::opencv_caffe::FillerParameter& bias_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler();
  ::opencv_caffe::FillerParameter* mutable_bias_filler();
  void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_bias_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler();
  public:
  void unsafe_arena_set_allocated_bias_filler(
      ::opencv_caffe::FillerParameter* bias_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler();

  // optional bool bias_term = 4 [default = false];
  bool has_bias_term() const;
  private:
  bool _internal_has_bias_term() const;
  public:
  void clear_bias_term();
  bool bias_term() const;
  void set_bias_term(bool value);
  private:
  bool _internal_bias_term() const;
  void _internal_set_bias_term(bool value);
  public:

  // optional int32 axis = 1 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // optional int32 num_axes = 2 [default = 1];
  bool has_num_axes() const;
  private:
  bool _internal_has_num_axes() const;
  public:
  void clear_num_axes();
  int32_t num_axes() const;
  void set_num_axes(int32_t value);
  private:
  int32_t _internal_num_axes() const;
  void _internal_set_num_axes(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ScaleParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* filler_;
    ::opencv_caffe::FillerParameter* bias_filler_;
    bool bias_term_;
    int32_t axis_;
    int32_t num_axes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SigmoidParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SigmoidParameter) */ {
 public:
  inline SigmoidParameter() : SigmoidParameter(nullptr) {}
  ~SigmoidParameter() override;
  explicit PROTOBUF_CONSTEXPR SigmoidParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SigmoidParameter& operator=(const SigmoidParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline SigmoidParameter& operator=(SigmoidParameter&& 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 SigmoidParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const SigmoidParameter* internal_default_instance() {
    return reinterpret_cast<const SigmoidParameter*>(
               &_SigmoidParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  friend void swap(SigmoidParameter& a, SigmoidParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(SigmoidParameter* 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(SigmoidParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SigmoidParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SigmoidParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SigmoidParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SigmoidParameter& from) {
    SigmoidParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SigmoidParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SigmoidParameter";
  }
  protected:
  explicit SigmoidParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 SigmoidParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    SigmoidParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    SigmoidParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    SigmoidParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return SigmoidParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    SigmoidParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    SigmoidParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    SigmoidParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return SigmoidParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return SigmoidParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return SigmoidParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kEngineFieldNumber = 1,
  };
  // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::SigmoidParameter_Engine engine() const;
  void set_engine(::opencv_caffe::SigmoidParameter_Engine value);
  private:
  ::opencv_caffe::SigmoidParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::SigmoidParameter_Engine value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SigmoidParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int engine_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SliceParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SliceParameter) */ {
 public:
  inline SliceParameter() : SliceParameter(nullptr) {}
  ~SliceParameter() override;
  explicit PROTOBUF_CONSTEXPR SliceParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SliceParameter& operator=(const SliceParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline SliceParameter& operator=(SliceParameter&& 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 SliceParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const SliceParameter* internal_default_instance() {
    return reinterpret_cast<const SliceParameter*>(
               &_SliceParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  friend void swap(SliceParameter& a, SliceParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(SliceParameter* 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(SliceParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SliceParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SliceParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SliceParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SliceParameter& from) {
    SliceParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SliceParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SliceParameter";
  }
  protected:
  explicit SliceParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kSlicePointFieldNumber = 2,
    kSliceDimFieldNumber = 1,
    kAxisFieldNumber = 3,
  };
  // repeated uint32 slice_point = 2;
  int slice_point_size() const;
  private:
  int _internal_slice_point_size() const;
  public:
  void clear_slice_point();
  private:
  uint32_t _internal_slice_point(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_slice_point() const;
  void _internal_add_slice_point(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_slice_point();
  public:
  uint32_t slice_point(int index) const;
  void set_slice_point(int index, uint32_t value);
  void add_slice_point(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      slice_point() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_slice_point();

  // optional uint32 slice_dim = 1 [default = 1];
  bool has_slice_dim() const;
  private:
  bool _internal_has_slice_dim() const;
  public:
  void clear_slice_dim();
  uint32_t slice_dim() const;
  void set_slice_dim(uint32_t value);
  private:
  uint32_t _internal_slice_dim() const;
  void _internal_set_slice_dim(uint32_t value);
  public:

  // optional int32 axis = 3 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SliceParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > slice_point_;
    uint32_t slice_dim_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SoftmaxParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SoftmaxParameter) */ {
 public:
  inline SoftmaxParameter() : SoftmaxParameter(nullptr) {}
  ~SoftmaxParameter() override;
  explicit PROTOBUF_CONSTEXPR SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SoftmaxParameter& operator=(const SoftmaxParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline SoftmaxParameter& operator=(SoftmaxParameter&& 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 SoftmaxParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const SoftmaxParameter* internal_default_instance() {
    return reinterpret_cast<const SoftmaxParameter*>(
               &_SoftmaxParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(SoftmaxParameter& a, SoftmaxParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(SoftmaxParameter* 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(SoftmaxParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SoftmaxParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SoftmaxParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SoftmaxParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SoftmaxParameter& from) {
    SoftmaxParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SoftmaxParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SoftmaxParameter";
  }
  protected:
  explicit SoftmaxParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 SoftmaxParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    SoftmaxParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    SoftmaxParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    SoftmaxParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return SoftmaxParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    SoftmaxParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    SoftmaxParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    SoftmaxParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return SoftmaxParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return SoftmaxParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return SoftmaxParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kEngineFieldNumber = 1,
    kAxisFieldNumber = 2,
  };
  // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::SoftmaxParameter_Engine engine() const;
  void set_engine(::opencv_caffe::SoftmaxParameter_Engine value);
  private:
  ::opencv_caffe::SoftmaxParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::SoftmaxParameter_Engine value);
  public:

  // optional int32 axis = 2 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SoftmaxParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int engine_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class TanHParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TanHParameter) */ {
 public:
  inline TanHParameter() : TanHParameter(nullptr) {}
  ~TanHParameter() override;
  explicit PROTOBUF_CONSTEXPR TanHParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TanHParameter& operator=(const TanHParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline TanHParameter& operator=(TanHParameter&& 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 TanHParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const TanHParameter* internal_default_instance() {
    return reinterpret_cast<const TanHParameter*>(
               &_TanHParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  friend void swap(TanHParameter& a, TanHParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(TanHParameter* 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(TanHParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TanHParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TanHParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TanHParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TanHParameter& from) {
    TanHParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TanHParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.TanHParameter";
  }
  protected:
  explicit TanHParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 TanHParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    TanHParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    TanHParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    TanHParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return TanHParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    TanHParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    TanHParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    TanHParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return TanHParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return TanHParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return TanHParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kEngineFieldNumber = 1,
  };
  // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::TanHParameter_Engine engine() const;
  void set_engine(::opencv_caffe::TanHParameter_Engine value);
  private:
  ::opencv_caffe::TanHParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::TanHParameter_Engine value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.TanHParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int engine_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class TileParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.TileParameter) */ {
 public:
  inline TileParameter() : TileParameter(nullptr) {}
  ~TileParameter() override;
  explicit PROTOBUF_CONSTEXPR TileParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TileParameter& operator=(const TileParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline TileParameter& operator=(TileParameter&& 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 TileParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const TileParameter* internal_default_instance() {
    return reinterpret_cast<const TileParameter*>(
               &_TileParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  friend void swap(TileParameter& a, TileParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(TileParameter* 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(TileParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TileParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TileParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TileParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TileParameter& from) {
    TileParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TileParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.TileParameter";
  }
  protected:
  explicit TileParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kTilesFieldNumber = 2,
    kAxisFieldNumber = 1,
  };
  // optional int32 tiles = 2;
  bool has_tiles() const;
  private:
  bool _internal_has_tiles() const;
  public:
  void clear_tiles();
  int32_t tiles() const;
  void set_tiles(int32_t value);
  private:
  int32_t _internal_tiles() const;
  void _internal_set_tiles(int32_t value);
  public:

  // optional int32 axis = 1 [default = 1];
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  int32_t axis() const;
  void set_axis(int32_t value);
  private:
  int32_t _internal_axis() const;
  void _internal_set_axis(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.TileParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t tiles_;
    int32_t axis_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ThresholdParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ThresholdParameter) */ {
 public:
  inline ThresholdParameter() : ThresholdParameter(nullptr) {}
  ~ThresholdParameter() override;
  explicit PROTOBUF_CONSTEXPR ThresholdParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ThresholdParameter& operator=(const ThresholdParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ThresholdParameter& operator=(ThresholdParameter&& 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 ThresholdParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ThresholdParameter* internal_default_instance() {
    return reinterpret_cast<const ThresholdParameter*>(
               &_ThresholdParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  friend void swap(ThresholdParameter& a, ThresholdParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ThresholdParameter* 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(ThresholdParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ThresholdParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ThresholdParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ThresholdParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ThresholdParameter& from) {
    ThresholdParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ThresholdParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ThresholdParameter";
  }
  protected:
  explicit ThresholdParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kThresholdFieldNumber = 1,
  };
  // optional float threshold = 1 [default = 0];
  bool has_threshold() const;
  private:
  bool _internal_has_threshold() const;
  public:
  void clear_threshold();
  float threshold() const;
  void set_threshold(float value);
  private:
  float _internal_threshold() const;
  void _internal_set_threshold(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ThresholdParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float threshold_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class WindowDataParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.WindowDataParameter) */ {
 public:
  inline WindowDataParameter() : WindowDataParameter(nullptr) {}
  ~WindowDataParameter() override;
  explicit PROTOBUF_CONSTEXPR WindowDataParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline WindowDataParameter& operator=(const WindowDataParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline WindowDataParameter& operator=(WindowDataParameter&& 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 WindowDataParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const WindowDataParameter* internal_default_instance() {
    return reinterpret_cast<const WindowDataParameter*>(
               &_WindowDataParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  friend void swap(WindowDataParameter& a, WindowDataParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(WindowDataParameter* 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(WindowDataParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  WindowDataParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WindowDataParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WindowDataParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WindowDataParameter& from) {
    WindowDataParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WindowDataParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.WindowDataParameter";
  }
  protected:
  explicit WindowDataParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kSourceFieldNumber = 1,
    kMeanFileFieldNumber = 3,
    kCropModeFieldNumber = 11,
    kRootFolderFieldNumber = 13,
    kBatchSizeFieldNumber = 4,
    kCropSizeFieldNumber = 5,
    kMirrorFieldNumber = 6,
    kCacheImagesFieldNumber = 12,
    kContextPadFieldNumber = 10,
    kScaleFieldNumber = 2,
    kFgThresholdFieldNumber = 7,
    kBgThresholdFieldNumber = 8,
    kFgFractionFieldNumber = 9,
  };
  // optional string source = 1;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional string mean_file = 3;
  bool has_mean_file() const;
  private:
  bool _internal_has_mean_file() const;
  public:
  void clear_mean_file();
  const std::string& mean_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mean_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mean_file();
  PROTOBUF_NODISCARD std::string* release_mean_file();
  void set_allocated_mean_file(std::string* mean_file);
  private:
  const std::string& _internal_mean_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mean_file(const std::string& value);
  std::string* _internal_mutable_mean_file();
  public:

  // optional string crop_mode = 11 [default = "warp"];
  bool has_crop_mode() const;
  private:
  bool _internal_has_crop_mode() const;
  public:
  void clear_crop_mode();
  const std::string& crop_mode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_crop_mode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_crop_mode();
  PROTOBUF_NODISCARD std::string* release_crop_mode();
  void set_allocated_crop_mode(std::string* crop_mode);
  private:
  const std::string& _internal_crop_mode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_crop_mode(const std::string& value);
  std::string* _internal_mutable_crop_mode();
  public:

  // optional string root_folder = 13 [default = ""];
  bool has_root_folder() const;
  private:
  bool _internal_has_root_folder() const;
  public:
  void clear_root_folder();
  const std::string& root_folder() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_root_folder(ArgT0&& arg0, ArgT... args);
  std::string* mutable_root_folder();
  PROTOBUF_NODISCARD std::string* release_root_folder();
  void set_allocated_root_folder(std::string* root_folder);
  private:
  const std::string& _internal_root_folder() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_root_folder(const std::string& value);
  std::string* _internal_mutable_root_folder();
  public:

  // optional uint32 batch_size = 4;
  bool has_batch_size() const;
  private:
  bool _internal_has_batch_size() const;
  public:
  void clear_batch_size();
  uint32_t batch_size() const;
  void set_batch_size(uint32_t value);
  private:
  uint32_t _internal_batch_size() const;
  void _internal_set_batch_size(uint32_t value);
  public:

  // optional uint32 crop_size = 5 [default = 0];
  bool has_crop_size() const;
  private:
  bool _internal_has_crop_size() const;
  public:
  void clear_crop_size();
  uint32_t crop_size() const;
  void set_crop_size(uint32_t value);
  private:
  uint32_t _internal_crop_size() const;
  void _internal_set_crop_size(uint32_t value);
  public:

  // optional bool mirror = 6 [default = false];
  bool has_mirror() const;
  private:
  bool _internal_has_mirror() const;
  public:
  void clear_mirror();
  bool mirror() const;
  void set_mirror(bool value);
  private:
  bool _internal_mirror() const;
  void _internal_set_mirror(bool value);
  public:

  // optional bool cache_images = 12 [default = false];
  bool has_cache_images() const;
  private:
  bool _internal_has_cache_images() const;
  public:
  void clear_cache_images();
  bool cache_images() const;
  void set_cache_images(bool value);
  private:
  bool _internal_cache_images() const;
  void _internal_set_cache_images(bool value);
  public:

  // optional uint32 context_pad = 10 [default = 0];
  bool has_context_pad() const;
  private:
  bool _internal_has_context_pad() const;
  public:
  void clear_context_pad();
  uint32_t context_pad() const;
  void set_context_pad(uint32_t value);
  private:
  uint32_t _internal_context_pad() const;
  void _internal_set_context_pad(uint32_t value);
  public:

  // optional float scale = 2 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // optional float fg_threshold = 7 [default = 0.5];
  bool has_fg_threshold() const;
  private:
  bool _internal_has_fg_threshold() const;
  public:
  void clear_fg_threshold();
  float fg_threshold() const;
  void set_fg_threshold(float value);
  private:
  float _internal_fg_threshold() const;
  void _internal_set_fg_threshold(float value);
  public:

  // optional float bg_threshold = 8 [default = 0.5];
  bool has_bg_threshold() const;
  private:
  bool _internal_has_bg_threshold() const;
  public:
  void clear_bg_threshold();
  float bg_threshold() const;
  void set_bg_threshold(float value);
  private:
  float _internal_bg_threshold() const;
  void _internal_set_bg_threshold(float value);
  public:

  // optional float fg_fraction = 9 [default = 0.25];
  bool has_fg_fraction() const;
  private:
  bool _internal_has_fg_fraction() const;
  public:
  void clear_fg_fraction();
  float fg_fraction() const;
  void set_fg_fraction(float value);
  private:
  float _internal_fg_fraction() const;
  void _internal_set_fg_fraction(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.WindowDataParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mean_file_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_crop_mode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr crop_mode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_folder_;
    uint32_t batch_size_;
    uint32_t crop_size_;
    bool mirror_;
    bool cache_images_;
    uint32_t context_pad_;
    float scale_;
    float fg_threshold_;
    float bg_threshold_;
    float fg_fraction_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class SPPParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.SPPParameter) */ {
 public:
  inline SPPParameter() : SPPParameter(nullptr) {}
  ~SPPParameter() override;
  explicit PROTOBUF_CONSTEXPR SPPParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SPPParameter& operator=(const SPPParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline SPPParameter& operator=(SPPParameter&& 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 SPPParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const SPPParameter* internal_default_instance() {
    return reinterpret_cast<const SPPParameter*>(
               &_SPPParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

  friend void swap(SPPParameter& a, SPPParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(SPPParameter* 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(SPPParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SPPParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SPPParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SPPParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SPPParameter& from) {
    SPPParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SPPParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.SPPParameter";
  }
  protected:
  explicit SPPParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 SPPParameter_PoolMethod PoolMethod;
  static constexpr PoolMethod MAX =
    SPPParameter_PoolMethod_MAX;
  static constexpr PoolMethod AVE =
    SPPParameter_PoolMethod_AVE;
  static constexpr PoolMethod STOCHASTIC =
    SPPParameter_PoolMethod_STOCHASTIC;
  static inline bool PoolMethod_IsValid(int value) {
    return SPPParameter_PoolMethod_IsValid(value);
  }
  static constexpr PoolMethod PoolMethod_MIN =
    SPPParameter_PoolMethod_PoolMethod_MIN;
  static constexpr PoolMethod PoolMethod_MAX =
    SPPParameter_PoolMethod_PoolMethod_MAX;
  static constexpr int PoolMethod_ARRAYSIZE =
    SPPParameter_PoolMethod_PoolMethod_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PoolMethod_descriptor() {
    return SPPParameter_PoolMethod_descriptor();
  }
  template<typename T>
  static inline const std::string& PoolMethod_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PoolMethod>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PoolMethod_Name.");
    return SPPParameter_PoolMethod_Name(enum_t_value);
  }
  static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PoolMethod* value) {
    return SPPParameter_PoolMethod_Parse(name, value);
  }

  typedef SPPParameter_Engine Engine;
  static constexpr Engine DEFAULT =
    SPPParameter_Engine_DEFAULT;
  static constexpr Engine CAFFE =
    SPPParameter_Engine_CAFFE;
  static constexpr Engine CUDNN =
    SPPParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return SPPParameter_Engine_IsValid(value);
  }
  static constexpr Engine Engine_MIN =
    SPPParameter_Engine_Engine_MIN;
  static constexpr Engine Engine_MAX =
    SPPParameter_Engine_Engine_MAX;
  static constexpr int Engine_ARRAYSIZE =
    SPPParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Engine_descriptor() {
    return SPPParameter_Engine_descriptor();
  }
  template<typename T>
  static inline const std::string& Engine_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Engine>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Engine_Name.");
    return SPPParameter_Engine_Name(enum_t_value);
  }
  static inline bool Engine_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Engine* value) {
    return SPPParameter_Engine_Parse(name, value);
  }

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

  enum : int {
    kPyramidHeightFieldNumber = 1,
    kPoolFieldNumber = 2,
    kEngineFieldNumber = 6,
  };
  // optional uint32 pyramid_height = 1;
  bool has_pyramid_height() const;
  private:
  bool _internal_has_pyramid_height() const;
  public:
  void clear_pyramid_height();
  uint32_t pyramid_height() const;
  void set_pyramid_height(uint32_t value);
  private:
  uint32_t _internal_pyramid_height() const;
  void _internal_set_pyramid_height(uint32_t value);
  public:

  // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
  bool has_pool() const;
  private:
  bool _internal_has_pool() const;
  public:
  void clear_pool();
  ::opencv_caffe::SPPParameter_PoolMethod pool() const;
  void set_pool(::opencv_caffe::SPPParameter_PoolMethod value);
  private:
  ::opencv_caffe::SPPParameter_PoolMethod _internal_pool() const;
  void _internal_set_pool(::opencv_caffe::SPPParameter_PoolMethod value);
  public:

  // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  ::opencv_caffe::SPPParameter_Engine engine() const;
  void set_engine(::opencv_caffe::SPPParameter_Engine value);
  private:
  ::opencv_caffe::SPPParameter_Engine _internal_engine() const;
  void _internal_set_engine(::opencv_caffe::SPPParameter_Engine value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.SPPParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t pyramid_height_;
    int pool_;
    int engine_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class V1LayerParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.V1LayerParameter) */ {
 public:
  inline V1LayerParameter() : V1LayerParameter(nullptr) {}
  ~V1LayerParameter() override;
  explicit PROTOBUF_CONSTEXPR V1LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline V1LayerParameter& operator=(const V1LayerParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline V1LayerParameter& operator=(V1LayerParameter&& 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 V1LayerParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const V1LayerParameter* internal_default_instance() {
    return reinterpret_cast<const V1LayerParameter*>(
               &_V1LayerParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(V1LayerParameter& a, V1LayerParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(V1LayerParameter* 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(V1LayerParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  V1LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<V1LayerParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const V1LayerParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const V1LayerParameter& from) {
    V1LayerParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(V1LayerParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.V1LayerParameter";
  }
  protected:
  explicit V1LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 V1LayerParameter_LayerType LayerType;
  static constexpr LayerType NONE =
    V1LayerParameter_LayerType_NONE;
  static constexpr LayerType ABSVAL =
    V1LayerParameter_LayerType_ABSVAL;
  static constexpr LayerType ACCURACY =
    V1LayerParameter_LayerType_ACCURACY;
  static constexpr LayerType ARGMAX =
    V1LayerParameter_LayerType_ARGMAX;
  static constexpr LayerType BNLL =
    V1LayerParameter_LayerType_BNLL;
  static constexpr LayerType CONCAT =
    V1LayerParameter_LayerType_CONCAT;
  static constexpr LayerType CONTRASTIVE_LOSS =
    V1LayerParameter_LayerType_CONTRASTIVE_LOSS;
  static constexpr LayerType CONVOLUTION =
    V1LayerParameter_LayerType_CONVOLUTION;
  static constexpr LayerType DATA =
    V1LayerParameter_LayerType_DATA;
  static constexpr LayerType DECONVOLUTION =
    V1LayerParameter_LayerType_DECONVOLUTION;
  static constexpr LayerType DROPOUT =
    V1LayerParameter_LayerType_DROPOUT;
  static constexpr LayerType DUMMY_DATA =
    V1LayerParameter_LayerType_DUMMY_DATA;
  static constexpr LayerType EUCLIDEAN_LOSS =
    V1LayerParameter_LayerType_EUCLIDEAN_LOSS;
  static constexpr LayerType ELTWISE =
    V1LayerParameter_LayerType_ELTWISE;
  static constexpr LayerType EXP =
    V1LayerParameter_LayerType_EXP;
  static constexpr LayerType FLATTEN =
    V1LayerParameter_LayerType_FLATTEN;
  static constexpr LayerType HDF5_DATA =
    V1LayerParameter_LayerType_HDF5_DATA;
  static constexpr LayerType HDF5_OUTPUT =
    V1LayerParameter_LayerType_HDF5_OUTPUT;
  static constexpr LayerType HINGE_LOSS =
    V1LayerParameter_LayerType_HINGE_LOSS;
  static constexpr LayerType IM2COL =
    V1LayerParameter_LayerType_IM2COL;
  static constexpr LayerType IMAGE_DATA =
    V1LayerParameter_LayerType_IMAGE_DATA;
  static constexpr LayerType INFOGAIN_LOSS =
    V1LayerParameter_LayerType_INFOGAIN_LOSS;
  static constexpr LayerType INNER_PRODUCT =
    V1LayerParameter_LayerType_INNER_PRODUCT;
  static constexpr LayerType LRN =
    V1LayerParameter_LayerType_LRN;
  static constexpr LayerType MEMORY_DATA =
    V1LayerParameter_LayerType_MEMORY_DATA;
  static constexpr LayerType MULTINOMIAL_LOGISTIC_LOSS =
    V1LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS;
  static constexpr LayerType MVN =
    V1LayerParameter_LayerType_MVN;
  static constexpr LayerType POOLING =
    V1LayerParameter_LayerType_POOLING;
  static constexpr LayerType POWER =
    V1LayerParameter_LayerType_POWER;
  static constexpr LayerType RELU =
    V1LayerParameter_LayerType_RELU;
  static constexpr LayerType SIGMOID =
    V1LayerParameter_LayerType_SIGMOID;
  static constexpr LayerType SIGMOID_CROSS_ENTROPY_LOSS =
    V1LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS;
  static constexpr LayerType SILENCE =
    V1LayerParameter_LayerType_SILENCE;
  static constexpr LayerType SOFTMAX =
    V1LayerParameter_LayerType_SOFTMAX;
  static constexpr LayerType SOFTMAX_LOSS =
    V1LayerParameter_LayerType_SOFTMAX_LOSS;
  static constexpr LayerType SPLIT =
    V1LayerParameter_LayerType_SPLIT;
  static constexpr LayerType SLICE =
    V1LayerParameter_LayerType_SLICE;
  static constexpr LayerType TANH =
    V1LayerParameter_LayerType_TANH;
  static constexpr LayerType WINDOW_DATA =
    V1LayerParameter_LayerType_WINDOW_DATA;
  static constexpr LayerType THRESHOLD =
    V1LayerParameter_LayerType_THRESHOLD;
  static inline bool LayerType_IsValid(int value) {
    return V1LayerParameter_LayerType_IsValid(value);
  }
  static constexpr LayerType LayerType_MIN =
    V1LayerParameter_LayerType_LayerType_MIN;
  static constexpr LayerType LayerType_MAX =
    V1LayerParameter_LayerType_LayerType_MAX;
  static constexpr int LayerType_ARRAYSIZE =
    V1LayerParameter_LayerType_LayerType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LayerType_descriptor() {
    return V1LayerParameter_LayerType_descriptor();
  }
  template<typename T>
  static inline const std::string& LayerType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LayerType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LayerType_Name.");
    return V1LayerParameter_LayerType_Name(enum_t_value);
  }
  static inline bool LayerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      LayerType* value) {
    return V1LayerParameter_LayerType_Parse(name, value);
  }

  typedef V1LayerParameter_DimCheckMode DimCheckMode;
  static constexpr DimCheckMode STRICT =
    V1LayerParameter_DimCheckMode_STRICT;
  static constexpr DimCheckMode PERMISSIVE =
    V1LayerParameter_DimCheckMode_PERMISSIVE;
  static inline bool DimCheckMode_IsValid(int value) {
    return V1LayerParameter_DimCheckMode_IsValid(value);
  }
  static constexpr DimCheckMode DimCheckMode_MIN =
    V1LayerParameter_DimCheckMode_DimCheckMode_MIN;
  static constexpr DimCheckMode DimCheckMode_MAX =
    V1LayerParameter_DimCheckMode_DimCheckMode_MAX;
  static constexpr int DimCheckMode_ARRAYSIZE =
    V1LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DimCheckMode_descriptor() {
    return V1LayerParameter_DimCheckMode_descriptor();
  }
  template<typename T>
  static inline const std::string& DimCheckMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DimCheckMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DimCheckMode_Name.");
    return V1LayerParameter_DimCheckMode_Name(enum_t_value);
  }
  static inline bool DimCheckMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DimCheckMode* value) {
    return V1LayerParameter_DimCheckMode_Parse(name, value);
  }

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

  enum : int {
    kBottomFieldNumber = 2,
    kTopFieldNumber = 3,
    kBlobsFieldNumber = 6,
    kBlobsLrFieldNumber = 7,
    kWeightDecayFieldNumber = 8,
    kIncludeFieldNumber = 32,
    kExcludeFieldNumber = 33,
    kLossWeightFieldNumber = 35,
    kParamFieldNumber = 1001,
    kBlobShareModeFieldNumber = 1002,
    kNameFieldNumber = 4,
    kLayerFieldNumber = 1,
    kConcatParamFieldNumber = 9,
    kConvolutionParamFieldNumber = 10,
    kDataParamFieldNumber = 11,
    kDropoutParamFieldNumber = 12,
    kHdf5DataParamFieldNumber = 13,
    kHdf5OutputParamFieldNumber = 14,
    kImageDataParamFieldNumber = 15,
    kInfogainLossParamFieldNumber = 16,
    kInnerProductParamFieldNumber = 17,
    kLrnParamFieldNumber = 18,
    kPoolingParamFieldNumber = 19,
    kWindowDataParamFieldNumber = 20,
    kPowerParamFieldNumber = 21,
    kMemoryDataParamFieldNumber = 22,
    kArgmaxParamFieldNumber = 23,
    kEltwiseParamFieldNumber = 24,
    kThresholdParamFieldNumber = 25,
    kDummyDataParamFieldNumber = 26,
    kAccuracyParamFieldNumber = 27,
    kHingeLossParamFieldNumber = 29,
    kReluParamFieldNumber = 30,
    kSliceParamFieldNumber = 31,
    kMvnParamFieldNumber = 34,
    kTransformParamFieldNumber = 36,
    kTanhParamFieldNumber = 37,
    kSigmoidParamFieldNumber = 38,
    kSoftmaxParamFieldNumber = 39,
    kContrastiveLossParamFieldNumber = 40,
    kExpParamFieldNumber = 41,
    kLossParamFieldNumber = 42,
    kTypeFieldNumber = 5,
  };
  // repeated string bottom = 2;
  int bottom_size() const;
  private:
  int _internal_bottom_size() const;
  public:
  void clear_bottom();
  const std::string& bottom(int index) const;
  std::string* mutable_bottom(int index);
  void set_bottom(int index, const std::string& value);
  void set_bottom(int index, std::string&& value);
  void set_bottom(int index, const char* value);
  void set_bottom(int index, const char* value, size_t size);
  std::string* add_bottom();
  void add_bottom(const std::string& value);
  void add_bottom(std::string&& value);
  void add_bottom(const char* value);
  void add_bottom(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bottom() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bottom();
  private:
  const std::string& _internal_bottom(int index) const;
  std::string* _internal_add_bottom();
  public:

  // repeated string top = 3;
  int top_size() const;
  private:
  int _internal_top_size() const;
  public:
  void clear_top();
  const std::string& top(int index) const;
  std::string* mutable_top(int index);
  void set_top(int index, const std::string& value);
  void set_top(int index, std::string&& value);
  void set_top(int index, const char* value);
  void set_top(int index, const char* value, size_t size);
  std::string* add_top();
  void add_top(const std::string& value);
  void add_top(std::string&& value);
  void add_top(const char* value);
  void add_top(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& top() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_top();
  private:
  const std::string& _internal_top(int index) const;
  std::string* _internal_add_top();
  public:

  // repeated .opencv_caffe.BlobProto blobs = 6;
  int blobs_size() const;
  private:
  int _internal_blobs_size() const;
  public:
  void clear_blobs();
  ::opencv_caffe::BlobProto* mutable_blobs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
      mutable_blobs();
  private:
  const ::opencv_caffe::BlobProto& _internal_blobs(int index) const;
  ::opencv_caffe::BlobProto* _internal_add_blobs();
  public:
  const ::opencv_caffe::BlobProto& blobs(int index) const;
  ::opencv_caffe::BlobProto* add_blobs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
      blobs() const;

  // repeated float blobs_lr = 7;
  int blobs_lr_size() const;
  private:
  int _internal_blobs_lr_size() const;
  public:
  void clear_blobs_lr();
  private:
  float _internal_blobs_lr(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_blobs_lr() const;
  void _internal_add_blobs_lr(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_blobs_lr();
  public:
  float blobs_lr(int index) const;
  void set_blobs_lr(int index, float value);
  void add_blobs_lr(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      blobs_lr() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_blobs_lr();

  // repeated float weight_decay = 8;
  int weight_decay_size() const;
  private:
  int _internal_weight_decay_size() const;
  public:
  void clear_weight_decay();
  private:
  float _internal_weight_decay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_weight_decay() const;
  void _internal_add_weight_decay(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_weight_decay();
  public:
  float weight_decay(int index) const;
  void set_weight_decay(int index, float value);
  void add_weight_decay(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      weight_decay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_weight_decay();

  // repeated .opencv_caffe.NetStateRule include = 32;
  int include_size() const;
  private:
  int _internal_include_size() const;
  public:
  void clear_include();
  ::opencv_caffe::NetStateRule* mutable_include(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
      mutable_include();
  private:
  const ::opencv_caffe::NetStateRule& _internal_include(int index) const;
  ::opencv_caffe::NetStateRule* _internal_add_include();
  public:
  const ::opencv_caffe::NetStateRule& include(int index) const;
  ::opencv_caffe::NetStateRule* add_include();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
      include() const;

  // repeated .opencv_caffe.NetStateRule exclude = 33;
  int exclude_size() const;
  private:
  int _internal_exclude_size() const;
  public:
  void clear_exclude();
  ::opencv_caffe::NetStateRule* mutable_exclude(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
      mutable_exclude();
  private:
  const ::opencv_caffe::NetStateRule& _internal_exclude(int index) const;
  ::opencv_caffe::NetStateRule* _internal_add_exclude();
  public:
  const ::opencv_caffe::NetStateRule& exclude(int index) const;
  ::opencv_caffe::NetStateRule* add_exclude();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
      exclude() const;

  // repeated float loss_weight = 35;
  int loss_weight_size() const;
  private:
  int _internal_loss_weight_size() const;
  public:
  void clear_loss_weight();
  private:
  float _internal_loss_weight(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_loss_weight() const;
  void _internal_add_loss_weight(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_loss_weight();
  public:
  float loss_weight(int index) const;
  void set_loss_weight(int index, float value);
  void add_loss_weight(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      loss_weight() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_loss_weight();

  // repeated string param = 1001;
  int param_size() const;
  private:
  int _internal_param_size() const;
  public:
  void clear_param();
  const std::string& param(int index) const;
  std::string* mutable_param(int index);
  void set_param(int index, const std::string& value);
  void set_param(int index, std::string&& value);
  void set_param(int index, const char* value);
  void set_param(int index, const char* value, size_t size);
  std::string* add_param();
  void add_param(const std::string& value);
  void add_param(std::string&& value);
  void add_param(const char* value);
  void add_param(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& param() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_param();
  private:
  const std::string& _internal_param(int index) const;
  std::string* _internal_add_param();
  public:

  // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
  int blob_share_mode_size() const;
  private:
  int _internal_blob_share_mode_size() const;
  public:
  void clear_blob_share_mode();
  private:
  ::opencv_caffe::V1LayerParameter_DimCheckMode _internal_blob_share_mode(int index) const;
  void _internal_add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_blob_share_mode();
  public:
  ::opencv_caffe::V1LayerParameter_DimCheckMode blob_share_mode(int index) const;
  void set_blob_share_mode(int index, ::opencv_caffe::V1LayerParameter_DimCheckMode value);
  void add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& blob_share_mode() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_blob_share_mode();

  // optional string name = 4;
  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 .opencv_caffe.V0LayerParameter layer = 1;
  bool has_layer() const;
  private:
  bool _internal_has_layer() const;
  public:
  void clear_layer();
  const ::opencv_caffe::V0LayerParameter& layer() const;
  PROTOBUF_NODISCARD ::opencv_caffe::V0LayerParameter* release_layer();
  ::opencv_caffe::V0LayerParameter* mutable_layer();
  void set_allocated_layer(::opencv_caffe::V0LayerParameter* layer);
  private:
  const ::opencv_caffe::V0LayerParameter& _internal_layer() const;
  ::opencv_caffe::V0LayerParameter* _internal_mutable_layer();
  public:
  void unsafe_arena_set_allocated_layer(
      ::opencv_caffe::V0LayerParameter* layer);
  ::opencv_caffe::V0LayerParameter* unsafe_arena_release_layer();

  // optional .opencv_caffe.ConcatParameter concat_param = 9;
  bool has_concat_param() const;
  private:
  bool _internal_has_concat_param() const;
  public:
  void clear_concat_param();
  const ::opencv_caffe::ConcatParameter& concat_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ConcatParameter* release_concat_param();
  ::opencv_caffe::ConcatParameter* mutable_concat_param();
  void set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param);
  private:
  const ::opencv_caffe::ConcatParameter& _internal_concat_param() const;
  ::opencv_caffe::ConcatParameter* _internal_mutable_concat_param();
  public:
  void unsafe_arena_set_allocated_concat_param(
      ::opencv_caffe::ConcatParameter* concat_param);
  ::opencv_caffe::ConcatParameter* unsafe_arena_release_concat_param();

  // optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
  bool has_convolution_param() const;
  private:
  bool _internal_has_convolution_param() const;
  public:
  void clear_convolution_param();
  const ::opencv_caffe::ConvolutionParameter& convolution_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ConvolutionParameter* release_convolution_param();
  ::opencv_caffe::ConvolutionParameter* mutable_convolution_param();
  void set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param);
  private:
  const ::opencv_caffe::ConvolutionParameter& _internal_convolution_param() const;
  ::opencv_caffe::ConvolutionParameter* _internal_mutable_convolution_param();
  public:
  void unsafe_arena_set_allocated_convolution_param(
      ::opencv_caffe::ConvolutionParameter* convolution_param);
  ::opencv_caffe::ConvolutionParameter* unsafe_arena_release_convolution_param();

  // optional .opencv_caffe.DataParameter data_param = 11;
  bool has_data_param() const;
  private:
  bool _internal_has_data_param() const;
  public:
  void clear_data_param();
  const ::opencv_caffe::DataParameter& data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DataParameter* release_data_param();
  ::opencv_caffe::DataParameter* mutable_data_param();
  void set_allocated_data_param(::opencv_caffe::DataParameter* data_param);
  private:
  const ::opencv_caffe::DataParameter& _internal_data_param() const;
  ::opencv_caffe::DataParameter* _internal_mutable_data_param();
  public:
  void unsafe_arena_set_allocated_data_param(
      ::opencv_caffe::DataParameter* data_param);
  ::opencv_caffe::DataParameter* unsafe_arena_release_data_param();

  // optional .opencv_caffe.DropoutParameter dropout_param = 12;
  bool has_dropout_param() const;
  private:
  bool _internal_has_dropout_param() const;
  public:
  void clear_dropout_param();
  const ::opencv_caffe::DropoutParameter& dropout_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DropoutParameter* release_dropout_param();
  ::opencv_caffe::DropoutParameter* mutable_dropout_param();
  void set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param);
  private:
  const ::opencv_caffe::DropoutParameter& _internal_dropout_param() const;
  ::opencv_caffe::DropoutParameter* _internal_mutable_dropout_param();
  public:
  void unsafe_arena_set_allocated_dropout_param(
      ::opencv_caffe::DropoutParameter* dropout_param);
  ::opencv_caffe::DropoutParameter* unsafe_arena_release_dropout_param();

  // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
  bool has_hdf5_data_param() const;
  private:
  bool _internal_has_hdf5_data_param() const;
  public:
  void clear_hdf5_data_param();
  const ::opencv_caffe::HDF5DataParameter& hdf5_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HDF5DataParameter* release_hdf5_data_param();
  ::opencv_caffe::HDF5DataParameter* mutable_hdf5_data_param();
  void set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param);
  private:
  const ::opencv_caffe::HDF5DataParameter& _internal_hdf5_data_param() const;
  ::opencv_caffe::HDF5DataParameter* _internal_mutable_hdf5_data_param();
  public:
  void unsafe_arena_set_allocated_hdf5_data_param(
      ::opencv_caffe::HDF5DataParameter* hdf5_data_param);
  ::opencv_caffe::HDF5DataParameter* unsafe_arena_release_hdf5_data_param();

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
  bool has_hdf5_output_param() const;
  private:
  bool _internal_has_hdf5_output_param() const;
  public:
  void clear_hdf5_output_param();
  const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HDF5OutputParameter* release_hdf5_output_param();
  ::opencv_caffe::HDF5OutputParameter* mutable_hdf5_output_param();
  void set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
  private:
  const ::opencv_caffe::HDF5OutputParameter& _internal_hdf5_output_param() const;
  ::opencv_caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param();
  public:
  void unsafe_arena_set_allocated_hdf5_output_param(
      ::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
  ::opencv_caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param();

  // optional .opencv_caffe.ImageDataParameter image_data_param = 15;
  bool has_image_data_param() const;
  private:
  bool _internal_has_image_data_param() const;
  public:
  void clear_image_data_param();
  const ::opencv_caffe::ImageDataParameter& image_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ImageDataParameter* release_image_data_param();
  ::opencv_caffe::ImageDataParameter* mutable_image_data_param();
  void set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param);
  private:
  const ::opencv_caffe::ImageDataParameter& _internal_image_data_param() const;
  ::opencv_caffe::ImageDataParameter* _internal_mutable_image_data_param();
  public:
  void unsafe_arena_set_allocated_image_data_param(
      ::opencv_caffe::ImageDataParameter* image_data_param);
  ::opencv_caffe::ImageDataParameter* unsafe_arena_release_image_data_param();

  // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
  bool has_infogain_loss_param() const;
  private:
  bool _internal_has_infogain_loss_param() const;
  public:
  void clear_infogain_loss_param();
  const ::opencv_caffe::InfogainLossParameter& infogain_loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::InfogainLossParameter* release_infogain_loss_param();
  ::opencv_caffe::InfogainLossParameter* mutable_infogain_loss_param();
  void set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param);
  private:
  const ::opencv_caffe::InfogainLossParameter& _internal_infogain_loss_param() const;
  ::opencv_caffe::InfogainLossParameter* _internal_mutable_infogain_loss_param();
  public:
  void unsafe_arena_set_allocated_infogain_loss_param(
      ::opencv_caffe::InfogainLossParameter* infogain_loss_param);
  ::opencv_caffe::InfogainLossParameter* unsafe_arena_release_infogain_loss_param();

  // optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
  bool has_inner_product_param() const;
  private:
  bool _internal_has_inner_product_param() const;
  public:
  void clear_inner_product_param();
  const ::opencv_caffe::InnerProductParameter& inner_product_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::InnerProductParameter* release_inner_product_param();
  ::opencv_caffe::InnerProductParameter* mutable_inner_product_param();
  void set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param);
  private:
  const ::opencv_caffe::InnerProductParameter& _internal_inner_product_param() const;
  ::opencv_caffe::InnerProductParameter* _internal_mutable_inner_product_param();
  public:
  void unsafe_arena_set_allocated_inner_product_param(
      ::opencv_caffe::InnerProductParameter* inner_product_param);
  ::opencv_caffe::InnerProductParameter* unsafe_arena_release_inner_product_param();

  // optional .opencv_caffe.LRNParameter lrn_param = 18;
  bool has_lrn_param() const;
  private:
  bool _internal_has_lrn_param() const;
  public:
  void clear_lrn_param();
  const ::opencv_caffe::LRNParameter& lrn_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::LRNParameter* release_lrn_param();
  ::opencv_caffe::LRNParameter* mutable_lrn_param();
  void set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param);
  private:
  const ::opencv_caffe::LRNParameter& _internal_lrn_param() const;
  ::opencv_caffe::LRNParameter* _internal_mutable_lrn_param();
  public:
  void unsafe_arena_set_allocated_lrn_param(
      ::opencv_caffe::LRNParameter* lrn_param);
  ::opencv_caffe::LRNParameter* unsafe_arena_release_lrn_param();

  // optional .opencv_caffe.PoolingParameter pooling_param = 19;
  bool has_pooling_param() const;
  private:
  bool _internal_has_pooling_param() const;
  public:
  void clear_pooling_param();
  const ::opencv_caffe::PoolingParameter& pooling_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PoolingParameter* release_pooling_param();
  ::opencv_caffe::PoolingParameter* mutable_pooling_param();
  void set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param);
  private:
  const ::opencv_caffe::PoolingParameter& _internal_pooling_param() const;
  ::opencv_caffe::PoolingParameter* _internal_mutable_pooling_param();
  public:
  void unsafe_arena_set_allocated_pooling_param(
      ::opencv_caffe::PoolingParameter* pooling_param);
  ::opencv_caffe::PoolingParameter* unsafe_arena_release_pooling_param();

  // optional .opencv_caffe.WindowDataParameter window_data_param = 20;
  bool has_window_data_param() const;
  private:
  bool _internal_has_window_data_param() const;
  public:
  void clear_window_data_param();
  const ::opencv_caffe::WindowDataParameter& window_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::WindowDataParameter* release_window_data_param();
  ::opencv_caffe::WindowDataParameter* mutable_window_data_param();
  void set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param);
  private:
  const ::opencv_caffe::WindowDataParameter& _internal_window_data_param() const;
  ::opencv_caffe::WindowDataParameter* _internal_mutable_window_data_param();
  public:
  void unsafe_arena_set_allocated_window_data_param(
      ::opencv_caffe::WindowDataParameter* window_data_param);
  ::opencv_caffe::WindowDataParameter* unsafe_arena_release_window_data_param();

  // optional .opencv_caffe.PowerParameter power_param = 21;
  bool has_power_param() const;
  private:
  bool _internal_has_power_param() const;
  public:
  void clear_power_param();
  const ::opencv_caffe::PowerParameter& power_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::PowerParameter* release_power_param();
  ::opencv_caffe::PowerParameter* mutable_power_param();
  void set_allocated_power_param(::opencv_caffe::PowerParameter* power_param);
  private:
  const ::opencv_caffe::PowerParameter& _internal_power_param() const;
  ::opencv_caffe::PowerParameter* _internal_mutable_power_param();
  public:
  void unsafe_arena_set_allocated_power_param(
      ::opencv_caffe::PowerParameter* power_param);
  ::opencv_caffe::PowerParameter* unsafe_arena_release_power_param();

  // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
  bool has_memory_data_param() const;
  private:
  bool _internal_has_memory_data_param() const;
  public:
  void clear_memory_data_param();
  const ::opencv_caffe::MemoryDataParameter& memory_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::MemoryDataParameter* release_memory_data_param();
  ::opencv_caffe::MemoryDataParameter* mutable_memory_data_param();
  void set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param);
  private:
  const ::opencv_caffe::MemoryDataParameter& _internal_memory_data_param() const;
  ::opencv_caffe::MemoryDataParameter* _internal_mutable_memory_data_param();
  public:
  void unsafe_arena_set_allocated_memory_data_param(
      ::opencv_caffe::MemoryDataParameter* memory_data_param);
  ::opencv_caffe::MemoryDataParameter* unsafe_arena_release_memory_data_param();

  // optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
  bool has_argmax_param() const;
  private:
  bool _internal_has_argmax_param() const;
  public:
  void clear_argmax_param();
  const ::opencv_caffe::ArgMaxParameter& argmax_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ArgMaxParameter* release_argmax_param();
  ::opencv_caffe::ArgMaxParameter* mutable_argmax_param();
  void set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param);
  private:
  const ::opencv_caffe::ArgMaxParameter& _internal_argmax_param() const;
  ::opencv_caffe::ArgMaxParameter* _internal_mutable_argmax_param();
  public:
  void unsafe_arena_set_allocated_argmax_param(
      ::opencv_caffe::ArgMaxParameter* argmax_param);
  ::opencv_caffe::ArgMaxParameter* unsafe_arena_release_argmax_param();

  // optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
  bool has_eltwise_param() const;
  private:
  bool _internal_has_eltwise_param() const;
  public:
  void clear_eltwise_param();
  const ::opencv_caffe::EltwiseParameter& eltwise_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::EltwiseParameter* release_eltwise_param();
  ::opencv_caffe::EltwiseParameter* mutable_eltwise_param();
  void set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param);
  private:
  const ::opencv_caffe::EltwiseParameter& _internal_eltwise_param() const;
  ::opencv_caffe::EltwiseParameter* _internal_mutable_eltwise_param();
  public:
  void unsafe_arena_set_allocated_eltwise_param(
      ::opencv_caffe::EltwiseParameter* eltwise_param);
  ::opencv_caffe::EltwiseParameter* unsafe_arena_release_eltwise_param();

  // optional .opencv_caffe.ThresholdParameter threshold_param = 25;
  bool has_threshold_param() const;
  private:
  bool _internal_has_threshold_param() const;
  public:
  void clear_threshold_param();
  const ::opencv_caffe::ThresholdParameter& threshold_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ThresholdParameter* release_threshold_param();
  ::opencv_caffe::ThresholdParameter* mutable_threshold_param();
  void set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param);
  private:
  const ::opencv_caffe::ThresholdParameter& _internal_threshold_param() const;
  ::opencv_caffe::ThresholdParameter* _internal_mutable_threshold_param();
  public:
  void unsafe_arena_set_allocated_threshold_param(
      ::opencv_caffe::ThresholdParameter* threshold_param);
  ::opencv_caffe::ThresholdParameter* unsafe_arena_release_threshold_param();

  // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
  bool has_dummy_data_param() const;
  private:
  bool _internal_has_dummy_data_param() const;
  public:
  void clear_dummy_data_param();
  const ::opencv_caffe::DummyDataParameter& dummy_data_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::DummyDataParameter* release_dummy_data_param();
  ::opencv_caffe::DummyDataParameter* mutable_dummy_data_param();
  void set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param);
  private:
  const ::opencv_caffe::DummyDataParameter& _internal_dummy_data_param() const;
  ::opencv_caffe::DummyDataParameter* _internal_mutable_dummy_data_param();
  public:
  void unsafe_arena_set_allocated_dummy_data_param(
      ::opencv_caffe::DummyDataParameter* dummy_data_param);
  ::opencv_caffe::DummyDataParameter* unsafe_arena_release_dummy_data_param();

  // optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
  bool has_accuracy_param() const;
  private:
  bool _internal_has_accuracy_param() const;
  public:
  void clear_accuracy_param();
  const ::opencv_caffe::AccuracyParameter& accuracy_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::AccuracyParameter* release_accuracy_param();
  ::opencv_caffe::AccuracyParameter* mutable_accuracy_param();
  void set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param);
  private:
  const ::opencv_caffe::AccuracyParameter& _internal_accuracy_param() const;
  ::opencv_caffe::AccuracyParameter* _internal_mutable_accuracy_param();
  public:
  void unsafe_arena_set_allocated_accuracy_param(
      ::opencv_caffe::AccuracyParameter* accuracy_param);
  ::opencv_caffe::AccuracyParameter* unsafe_arena_release_accuracy_param();

  // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
  bool has_hinge_loss_param() const;
  private:
  bool _internal_has_hinge_loss_param() const;
  public:
  void clear_hinge_loss_param();
  const ::opencv_caffe::HingeLossParameter& hinge_loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HingeLossParameter* release_hinge_loss_param();
  ::opencv_caffe::HingeLossParameter* mutable_hinge_loss_param();
  void set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param);
  private:
  const ::opencv_caffe::HingeLossParameter& _internal_hinge_loss_param() const;
  ::opencv_caffe::HingeLossParameter* _internal_mutable_hinge_loss_param();
  public:
  void unsafe_arena_set_allocated_hinge_loss_param(
      ::opencv_caffe::HingeLossParameter* hinge_loss_param);
  ::opencv_caffe::HingeLossParameter* unsafe_arena_release_hinge_loss_param();

  // optional .opencv_caffe.ReLUParameter relu_param = 30;
  bool has_relu_param() const;
  private:
  bool _internal_has_relu_param() const;
  public:
  void clear_relu_param();
  const ::opencv_caffe::ReLUParameter& relu_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ReLUParameter* release_relu_param();
  ::opencv_caffe::ReLUParameter* mutable_relu_param();
  void set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param);
  private:
  const ::opencv_caffe::ReLUParameter& _internal_relu_param() const;
  ::opencv_caffe::ReLUParameter* _internal_mutable_relu_param();
  public:
  void unsafe_arena_set_allocated_relu_param(
      ::opencv_caffe::ReLUParameter* relu_param);
  ::opencv_caffe::ReLUParameter* unsafe_arena_release_relu_param();

  // optional .opencv_caffe.SliceParameter slice_param = 31;
  bool has_slice_param() const;
  private:
  bool _internal_has_slice_param() const;
  public:
  void clear_slice_param();
  const ::opencv_caffe::SliceParameter& slice_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SliceParameter* release_slice_param();
  ::opencv_caffe::SliceParameter* mutable_slice_param();
  void set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param);
  private:
  const ::opencv_caffe::SliceParameter& _internal_slice_param() const;
  ::opencv_caffe::SliceParameter* _internal_mutable_slice_param();
  public:
  void unsafe_arena_set_allocated_slice_param(
      ::opencv_caffe::SliceParameter* slice_param);
  ::opencv_caffe::SliceParameter* unsafe_arena_release_slice_param();

  // optional .opencv_caffe.MVNParameter mvn_param = 34;
  bool has_mvn_param() const;
  private:
  bool _internal_has_mvn_param() const;
  public:
  void clear_mvn_param();
  const ::opencv_caffe::MVNParameter& mvn_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::MVNParameter* release_mvn_param();
  ::opencv_caffe::MVNParameter* mutable_mvn_param();
  void set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param);
  private:
  const ::opencv_caffe::MVNParameter& _internal_mvn_param() const;
  ::opencv_caffe::MVNParameter* _internal_mutable_mvn_param();
  public:
  void unsafe_arena_set_allocated_mvn_param(
      ::opencv_caffe::MVNParameter* mvn_param);
  ::opencv_caffe::MVNParameter* unsafe_arena_release_mvn_param();

  // optional .opencv_caffe.TransformationParameter transform_param = 36;
  bool has_transform_param() const;
  private:
  bool _internal_has_transform_param() const;
  public:
  void clear_transform_param();
  const ::opencv_caffe::TransformationParameter& transform_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::TransformationParameter* release_transform_param();
  ::opencv_caffe::TransformationParameter* mutable_transform_param();
  void set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param);
  private:
  const ::opencv_caffe::TransformationParameter& _internal_transform_param() const;
  ::opencv_caffe::TransformationParameter* _internal_mutable_transform_param();
  public:
  void unsafe_arena_set_allocated_transform_param(
      ::opencv_caffe::TransformationParameter* transform_param);
  ::opencv_caffe::TransformationParameter* unsafe_arena_release_transform_param();

  // optional .opencv_caffe.TanHParameter tanh_param = 37;
  bool has_tanh_param() const;
  private:
  bool _internal_has_tanh_param() const;
  public:
  void clear_tanh_param();
  const ::opencv_caffe::TanHParameter& tanh_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::TanHParameter* release_tanh_param();
  ::opencv_caffe::TanHParameter* mutable_tanh_param();
  void set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param);
  private:
  const ::opencv_caffe::TanHParameter& _internal_tanh_param() const;
  ::opencv_caffe::TanHParameter* _internal_mutable_tanh_param();
  public:
  void unsafe_arena_set_allocated_tanh_param(
      ::opencv_caffe::TanHParameter* tanh_param);
  ::opencv_caffe::TanHParameter* unsafe_arena_release_tanh_param();

  // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
  bool has_sigmoid_param() const;
  private:
  bool _internal_has_sigmoid_param() const;
  public:
  void clear_sigmoid_param();
  const ::opencv_caffe::SigmoidParameter& sigmoid_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SigmoidParameter* release_sigmoid_param();
  ::opencv_caffe::SigmoidParameter* mutable_sigmoid_param();
  void set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param);
  private:
  const ::opencv_caffe::SigmoidParameter& _internal_sigmoid_param() const;
  ::opencv_caffe::SigmoidParameter* _internal_mutable_sigmoid_param();
  public:
  void unsafe_arena_set_allocated_sigmoid_param(
      ::opencv_caffe::SigmoidParameter* sigmoid_param);
  ::opencv_caffe::SigmoidParameter* unsafe_arena_release_sigmoid_param();

  // optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
  bool has_softmax_param() const;
  private:
  bool _internal_has_softmax_param() const;
  public:
  void clear_softmax_param();
  const ::opencv_caffe::SoftmaxParameter& softmax_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::SoftmaxParameter* release_softmax_param();
  ::opencv_caffe::SoftmaxParameter* mutable_softmax_param();
  void set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param);
  private:
  const ::opencv_caffe::SoftmaxParameter& _internal_softmax_param() const;
  ::opencv_caffe::SoftmaxParameter* _internal_mutable_softmax_param();
  public:
  void unsafe_arena_set_allocated_softmax_param(
      ::opencv_caffe::SoftmaxParameter* softmax_param);
  ::opencv_caffe::SoftmaxParameter* unsafe_arena_release_softmax_param();

  // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
  bool has_contrastive_loss_param() const;
  private:
  bool _internal_has_contrastive_loss_param() const;
  public:
  void clear_contrastive_loss_param();
  const ::opencv_caffe::ContrastiveLossParameter& contrastive_loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ContrastiveLossParameter* release_contrastive_loss_param();
  ::opencv_caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
  void set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param);
  private:
  const ::opencv_caffe::ContrastiveLossParameter& _internal_contrastive_loss_param() const;
  ::opencv_caffe::ContrastiveLossParameter* _internal_mutable_contrastive_loss_param();
  public:
  void unsafe_arena_set_allocated_contrastive_loss_param(
      ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param);
  ::opencv_caffe::ContrastiveLossParameter* unsafe_arena_release_contrastive_loss_param();

  // optional .opencv_caffe.ExpParameter exp_param = 41;
  bool has_exp_param() const;
  private:
  bool _internal_has_exp_param() const;
  public:
  void clear_exp_param();
  const ::opencv_caffe::ExpParameter& exp_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::ExpParameter* release_exp_param();
  ::opencv_caffe::ExpParameter* mutable_exp_param();
  void set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param);
  private:
  const ::opencv_caffe::ExpParameter& _internal_exp_param() const;
  ::opencv_caffe::ExpParameter* _internal_mutable_exp_param();
  public:
  void unsafe_arena_set_allocated_exp_param(
      ::opencv_caffe::ExpParameter* exp_param);
  ::opencv_caffe::ExpParameter* unsafe_arena_release_exp_param();

  // optional .opencv_caffe.LossParameter loss_param = 42;
  bool has_loss_param() const;
  private:
  bool _internal_has_loss_param() const;
  public:
  void clear_loss_param();
  const ::opencv_caffe::LossParameter& loss_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::LossParameter* release_loss_param();
  ::opencv_caffe::LossParameter* mutable_loss_param();
  void set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param);
  private:
  const ::opencv_caffe::LossParameter& _internal_loss_param() const;
  ::opencv_caffe::LossParameter* _internal_mutable_loss_param();
  public:
  void unsafe_arena_set_allocated_loss_param(
      ::opencv_caffe::LossParameter* loss_param);
  ::opencv_caffe::LossParameter* unsafe_arena_release_loss_param();

  // optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::opencv_caffe::V1LayerParameter_LayerType type() const;
  void set_type(::opencv_caffe::V1LayerParameter_LayerType value);
  private:
  ::opencv_caffe::V1LayerParameter_LayerType _internal_type() const;
  void _internal_set_type(::opencv_caffe::V1LayerParameter_LayerType value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.V1LayerParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bottom_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> top_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > blobs_lr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > weight_decay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > include_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule > exclude_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > loss_weight_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> param_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> blob_share_mode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::opencv_caffe::V0LayerParameter* layer_;
    ::opencv_caffe::ConcatParameter* concat_param_;
    ::opencv_caffe::ConvolutionParameter* convolution_param_;
    ::opencv_caffe::DataParameter* data_param_;
    ::opencv_caffe::DropoutParameter* dropout_param_;
    ::opencv_caffe::HDF5DataParameter* hdf5_data_param_;
    ::opencv_caffe::HDF5OutputParameter* hdf5_output_param_;
    ::opencv_caffe::ImageDataParameter* image_data_param_;
    ::opencv_caffe::InfogainLossParameter* infogain_loss_param_;
    ::opencv_caffe::InnerProductParameter* inner_product_param_;
    ::opencv_caffe::LRNParameter* lrn_param_;
    ::opencv_caffe::PoolingParameter* pooling_param_;
    ::opencv_caffe::WindowDataParameter* window_data_param_;
    ::opencv_caffe::PowerParameter* power_param_;
    ::opencv_caffe::MemoryDataParameter* memory_data_param_;
    ::opencv_caffe::ArgMaxParameter* argmax_param_;
    ::opencv_caffe::EltwiseParameter* eltwise_param_;
    ::opencv_caffe::ThresholdParameter* threshold_param_;
    ::opencv_caffe::DummyDataParameter* dummy_data_param_;
    ::opencv_caffe::AccuracyParameter* accuracy_param_;
    ::opencv_caffe::HingeLossParameter* hinge_loss_param_;
    ::opencv_caffe::ReLUParameter* relu_param_;
    ::opencv_caffe::SliceParameter* slice_param_;
    ::opencv_caffe::MVNParameter* mvn_param_;
    ::opencv_caffe::TransformationParameter* transform_param_;
    ::opencv_caffe::TanHParameter* tanh_param_;
    ::opencv_caffe::SigmoidParameter* sigmoid_param_;
    ::opencv_caffe::SoftmaxParameter* softmax_param_;
    ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param_;
    ::opencv_caffe::ExpParameter* exp_param_;
    ::opencv_caffe::LossParameter* loss_param_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class V0LayerParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.V0LayerParameter) */ {
 public:
  inline V0LayerParameter() : V0LayerParameter(nullptr) {}
  ~V0LayerParameter() override;
  explicit PROTOBUF_CONSTEXPR V0LayerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline V0LayerParameter& operator=(const V0LayerParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline V0LayerParameter& operator=(V0LayerParameter&& 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 V0LayerParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const V0LayerParameter* internal_default_instance() {
    return reinterpret_cast<const V0LayerParameter*>(
               &_V0LayerParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  friend void swap(V0LayerParameter& a, V0LayerParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(V0LayerParameter* 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(V0LayerParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  V0LayerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<V0LayerParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const V0LayerParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const V0LayerParameter& from) {
    V0LayerParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(V0LayerParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.V0LayerParameter";
  }
  protected:
  explicit V0LayerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 V0LayerParameter_PoolMethod PoolMethod;
  static constexpr PoolMethod MAX =
    V0LayerParameter_PoolMethod_MAX;
  static constexpr PoolMethod AVE =
    V0LayerParameter_PoolMethod_AVE;
  static constexpr PoolMethod STOCHASTIC =
    V0LayerParameter_PoolMethod_STOCHASTIC;
  static inline bool PoolMethod_IsValid(int value) {
    return V0LayerParameter_PoolMethod_IsValid(value);
  }
  static constexpr PoolMethod PoolMethod_MIN =
    V0LayerParameter_PoolMethod_PoolMethod_MIN;
  static constexpr PoolMethod PoolMethod_MAX =
    V0LayerParameter_PoolMethod_PoolMethod_MAX;
  static constexpr int PoolMethod_ARRAYSIZE =
    V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PoolMethod_descriptor() {
    return V0LayerParameter_PoolMethod_descriptor();
  }
  template<typename T>
  static inline const std::string& PoolMethod_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PoolMethod>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PoolMethod_Name.");
    return V0LayerParameter_PoolMethod_Name(enum_t_value);
  }
  static inline bool PoolMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PoolMethod* value) {
    return V0LayerParameter_PoolMethod_Parse(name, value);
  }

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

  enum : int {
    kBlobsFieldNumber = 50,
    kBlobsLrFieldNumber = 51,
    kWeightDecayFieldNumber = 52,
    kNameFieldNumber = 1,
    kTypeFieldNumber = 2,
    kSourceFieldNumber = 16,
    kMeanfileFieldNumber = 18,
    kDetCropModeFieldNumber = 59,
    kWeightFillerFieldNumber = 5,
    kBiasFillerFieldNumber = 6,
    kHdf5OutputParamFieldNumber = 1001,
    kNumOutputFieldNumber = 3,
    kPadFieldNumber = 7,
    kKernelsizeFieldNumber = 8,
    kPoolFieldNumber = 11,
    kBatchsizeFieldNumber = 19,
    kCropsizeFieldNumber = 20,
    kMirrorFieldNumber = 21,
    kShuffleImagesFieldNumber = 64,
    kRandSkipFieldNumber = 53,
    kDetContextPadFieldNumber = 58,
    kNewNumFieldNumber = 60,
    kNewChannelsFieldNumber = 61,
    kNewHeightFieldNumber = 62,
    kNewWidthFieldNumber = 63,
    kConcatDimFieldNumber = 65,
    kBiastermFieldNumber = 4,
    kGroupFieldNumber = 9,
    kStrideFieldNumber = 10,
    kDropoutRatioFieldNumber = 12,
    kLocalSizeFieldNumber = 13,
    kAlphaFieldNumber = 14,
    kBetaFieldNumber = 15,
    kScaleFieldNumber = 17,
    kKFieldNumber = 22,
    kDetFgThresholdFieldNumber = 54,
    kDetBgThresholdFieldNumber = 55,
    kDetFgFractionFieldNumber = 56,
  };
  // repeated .opencv_caffe.BlobProto blobs = 50;
  int blobs_size() const;
  private:
  int _internal_blobs_size() const;
  public:
  void clear_blobs();
  ::opencv_caffe::BlobProto* mutable_blobs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
      mutable_blobs();
  private:
  const ::opencv_caffe::BlobProto& _internal_blobs(int index) const;
  ::opencv_caffe::BlobProto* _internal_add_blobs();
  public:
  const ::opencv_caffe::BlobProto& blobs(int index) const;
  ::opencv_caffe::BlobProto* add_blobs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
      blobs() const;

  // repeated float blobs_lr = 51;
  int blobs_lr_size() const;
  private:
  int _internal_blobs_lr_size() const;
  public:
  void clear_blobs_lr();
  private:
  float _internal_blobs_lr(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_blobs_lr() const;
  void _internal_add_blobs_lr(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_blobs_lr();
  public:
  float blobs_lr(int index) const;
  void set_blobs_lr(int index, float value);
  void add_blobs_lr(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      blobs_lr() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_blobs_lr();

  // repeated float weight_decay = 52;
  int weight_decay_size() const;
  private:
  int _internal_weight_decay_size() const;
  public:
  void clear_weight_decay();
  private:
  float _internal_weight_decay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_weight_decay() const;
  void _internal_add_weight_decay(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_weight_decay();
  public:
  float weight_decay(int index) const;
  void set_weight_decay(int index, float value);
  void add_weight_decay(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      weight_decay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_weight_decay();

  // optional 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 string type = 2;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // optional string source = 16;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional string meanfile = 18;
  bool has_meanfile() const;
  private:
  bool _internal_has_meanfile() const;
  public:
  void clear_meanfile();
  const std::string& meanfile() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_meanfile(ArgT0&& arg0, ArgT... args);
  std::string* mutable_meanfile();
  PROTOBUF_NODISCARD std::string* release_meanfile();
  void set_allocated_meanfile(std::string* meanfile);
  private:
  const std::string& _internal_meanfile() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_meanfile(const std::string& value);
  std::string* _internal_mutable_meanfile();
  public:

  // optional string det_crop_mode = 59 [default = "warp"];
  bool has_det_crop_mode() const;
  private:
  bool _internal_has_det_crop_mode() const;
  public:
  void clear_det_crop_mode();
  const std::string& det_crop_mode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_det_crop_mode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_det_crop_mode();
  PROTOBUF_NODISCARD std::string* release_det_crop_mode();
  void set_allocated_det_crop_mode(std::string* det_crop_mode);
  private:
  const std::string& _internal_det_crop_mode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_det_crop_mode(const std::string& value);
  std::string* _internal_mutable_det_crop_mode();
  public:

  // optional .opencv_caffe.FillerParameter weight_filler = 5;
  bool has_weight_filler() const;
  private:
  bool _internal_has_weight_filler() const;
  public:
  void clear_weight_filler();
  const ::opencv_caffe::FillerParameter& weight_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_weight_filler();
  ::opencv_caffe::FillerParameter* mutable_weight_filler();
  void set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_weight_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_weight_filler();
  public:
  void unsafe_arena_set_allocated_weight_filler(
      ::opencv_caffe::FillerParameter* weight_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_weight_filler();

  // optional .opencv_caffe.FillerParameter bias_filler = 6;
  bool has_bias_filler() const;
  private:
  bool _internal_has_bias_filler() const;
  public:
  void clear_bias_filler();
  const ::opencv_caffe::FillerParameter& bias_filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_bias_filler();
  ::opencv_caffe::FillerParameter* mutable_bias_filler();
  void set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_bias_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_bias_filler();
  public:
  void unsafe_arena_set_allocated_bias_filler(
      ::opencv_caffe::FillerParameter* bias_filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_bias_filler();

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
  bool has_hdf5_output_param() const;
  private:
  bool _internal_has_hdf5_output_param() const;
  public:
  void clear_hdf5_output_param();
  const ::opencv_caffe::HDF5OutputParameter& hdf5_output_param() const;
  PROTOBUF_NODISCARD ::opencv_caffe::HDF5OutputParameter* release_hdf5_output_param();
  ::opencv_caffe::HDF5OutputParameter* mutable_hdf5_output_param();
  void set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
  private:
  const ::opencv_caffe::HDF5OutputParameter& _internal_hdf5_output_param() const;
  ::opencv_caffe::HDF5OutputParameter* _internal_mutable_hdf5_output_param();
  public:
  void unsafe_arena_set_allocated_hdf5_output_param(
      ::opencv_caffe::HDF5OutputParameter* hdf5_output_param);
  ::opencv_caffe::HDF5OutputParameter* unsafe_arena_release_hdf5_output_param();

  // optional uint32 num_output = 3;
  bool has_num_output() const;
  private:
  bool _internal_has_num_output() const;
  public:
  void clear_num_output();
  uint32_t num_output() const;
  void set_num_output(uint32_t value);
  private:
  uint32_t _internal_num_output() const;
  void _internal_set_num_output(uint32_t value);
  public:

  // optional uint32 pad = 7 [default = 0];
  bool has_pad() const;
  private:
  bool _internal_has_pad() const;
  public:
  void clear_pad();
  uint32_t pad() const;
  void set_pad(uint32_t value);
  private:
  uint32_t _internal_pad() const;
  void _internal_set_pad(uint32_t value);
  public:

  // optional uint32 kernelsize = 8;
  bool has_kernelsize() const;
  private:
  bool _internal_has_kernelsize() const;
  public:
  void clear_kernelsize();
  uint32_t kernelsize() const;
  void set_kernelsize(uint32_t value);
  private:
  uint32_t _internal_kernelsize() const;
  void _internal_set_kernelsize(uint32_t value);
  public:

  // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
  bool has_pool() const;
  private:
  bool _internal_has_pool() const;
  public:
  void clear_pool();
  ::opencv_caffe::V0LayerParameter_PoolMethod pool() const;
  void set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value);
  private:
  ::opencv_caffe::V0LayerParameter_PoolMethod _internal_pool() const;
  void _internal_set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value);
  public:

  // optional uint32 batchsize = 19;
  bool has_batchsize() const;
  private:
  bool _internal_has_batchsize() const;
  public:
  void clear_batchsize();
  uint32_t batchsize() const;
  void set_batchsize(uint32_t value);
  private:
  uint32_t _internal_batchsize() const;
  void _internal_set_batchsize(uint32_t value);
  public:

  // optional uint32 cropsize = 20 [default = 0];
  bool has_cropsize() const;
  private:
  bool _internal_has_cropsize() const;
  public:
  void clear_cropsize();
  uint32_t cropsize() const;
  void set_cropsize(uint32_t value);
  private:
  uint32_t _internal_cropsize() const;
  void _internal_set_cropsize(uint32_t value);
  public:

  // optional bool mirror = 21 [default = false];
  bool has_mirror() const;
  private:
  bool _internal_has_mirror() const;
  public:
  void clear_mirror();
  bool mirror() const;
  void set_mirror(bool value);
  private:
  bool _internal_mirror() const;
  void _internal_set_mirror(bool value);
  public:

  // optional bool shuffle_images = 64 [default = false];
  bool has_shuffle_images() const;
  private:
  bool _internal_has_shuffle_images() const;
  public:
  void clear_shuffle_images();
  bool shuffle_images() const;
  void set_shuffle_images(bool value);
  private:
  bool _internal_shuffle_images() const;
  void _internal_set_shuffle_images(bool value);
  public:

  // optional uint32 rand_skip = 53 [default = 0];
  bool has_rand_skip() const;
  private:
  bool _internal_has_rand_skip() const;
  public:
  void clear_rand_skip();
  uint32_t rand_skip() const;
  void set_rand_skip(uint32_t value);
  private:
  uint32_t _internal_rand_skip() const;
  void _internal_set_rand_skip(uint32_t value);
  public:

  // optional uint32 det_context_pad = 58 [default = 0];
  bool has_det_context_pad() const;
  private:
  bool _internal_has_det_context_pad() const;
  public:
  void clear_det_context_pad();
  uint32_t det_context_pad() const;
  void set_det_context_pad(uint32_t value);
  private:
  uint32_t _internal_det_context_pad() const;
  void _internal_set_det_context_pad(uint32_t value);
  public:

  // optional int32 new_num = 60 [default = 0];
  bool has_new_num() const;
  private:
  bool _internal_has_new_num() const;
  public:
  void clear_new_num();
  int32_t new_num() const;
  void set_new_num(int32_t value);
  private:
  int32_t _internal_new_num() const;
  void _internal_set_new_num(int32_t value);
  public:

  // optional int32 new_channels = 61 [default = 0];
  bool has_new_channels() const;
  private:
  bool _internal_has_new_channels() const;
  public:
  void clear_new_channels();
  int32_t new_channels() const;
  void set_new_channels(int32_t value);
  private:
  int32_t _internal_new_channels() const;
  void _internal_set_new_channels(int32_t value);
  public:

  // optional int32 new_height = 62 [default = 0];
  bool has_new_height() const;
  private:
  bool _internal_has_new_height() const;
  public:
  void clear_new_height();
  int32_t new_height() const;
  void set_new_height(int32_t value);
  private:
  int32_t _internal_new_height() const;
  void _internal_set_new_height(int32_t value);
  public:

  // optional int32 new_width = 63 [default = 0];
  bool has_new_width() const;
  private:
  bool _internal_has_new_width() const;
  public:
  void clear_new_width();
  int32_t new_width() const;
  void set_new_width(int32_t value);
  private:
  int32_t _internal_new_width() const;
  void _internal_set_new_width(int32_t value);
  public:

  // optional uint32 concat_dim = 65 [default = 1];
  bool has_concat_dim() const;
  private:
  bool _internal_has_concat_dim() const;
  public:
  void clear_concat_dim();
  uint32_t concat_dim() const;
  void set_concat_dim(uint32_t value);
  private:
  uint32_t _internal_concat_dim() const;
  void _internal_set_concat_dim(uint32_t value);
  public:

  // optional bool biasterm = 4 [default = true];
  bool has_biasterm() const;
  private:
  bool _internal_has_biasterm() const;
  public:
  void clear_biasterm();
  bool biasterm() const;
  void set_biasterm(bool value);
  private:
  bool _internal_biasterm() const;
  void _internal_set_biasterm(bool value);
  public:

  // optional uint32 group = 9 [default = 1];
  bool has_group() const;
  private:
  bool _internal_has_group() const;
  public:
  void clear_group();
  uint32_t group() const;
  void set_group(uint32_t value);
  private:
  uint32_t _internal_group() const;
  void _internal_set_group(uint32_t value);
  public:

  // optional uint32 stride = 10 [default = 1];
  bool has_stride() const;
  private:
  bool _internal_has_stride() const;
  public:
  void clear_stride();
  uint32_t stride() const;
  void set_stride(uint32_t value);
  private:
  uint32_t _internal_stride() const;
  void _internal_set_stride(uint32_t value);
  public:

  // optional float dropout_ratio = 12 [default = 0.5];
  bool has_dropout_ratio() const;
  private:
  bool _internal_has_dropout_ratio() const;
  public:
  void clear_dropout_ratio();
  float dropout_ratio() const;
  void set_dropout_ratio(float value);
  private:
  float _internal_dropout_ratio() const;
  void _internal_set_dropout_ratio(float value);
  public:

  // optional uint32 local_size = 13 [default = 5];
  bool has_local_size() const;
  private:
  bool _internal_has_local_size() const;
  public:
  void clear_local_size();
  uint32_t local_size() const;
  void set_local_size(uint32_t value);
  private:
  uint32_t _internal_local_size() const;
  void _internal_set_local_size(uint32_t value);
  public:

  // optional float alpha = 14 [default = 1];
  bool has_alpha() const;
  private:
  bool _internal_has_alpha() const;
  public:
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);
  private:
  float _internal_alpha() const;
  void _internal_set_alpha(float value);
  public:

  // optional float beta = 15 [default = 0.75];
  bool has_beta() const;
  private:
  bool _internal_has_beta() const;
  public:
  void clear_beta();
  float beta() const;
  void set_beta(float value);
  private:
  float _internal_beta() const;
  void _internal_set_beta(float value);
  public:

  // optional float scale = 17 [default = 1];
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // optional float k = 22 [default = 1];
  bool has_k() const;
  private:
  bool _internal_has_k() const;
  public:
  void clear_k();
  float k() const;
  void set_k(float value);
  private:
  float _internal_k() const;
  void _internal_set_k(float value);
  public:

  // optional float det_fg_threshold = 54 [default = 0.5];
  bool has_det_fg_threshold() const;
  private:
  bool _internal_has_det_fg_threshold() const;
  public:
  void clear_det_fg_threshold();
  float det_fg_threshold() const;
  void set_det_fg_threshold(float value);
  private:
  float _internal_det_fg_threshold() const;
  void _internal_set_det_fg_threshold(float value);
  public:

  // optional float det_bg_threshold = 55 [default = 0.5];
  bool has_det_bg_threshold() const;
  private:
  bool _internal_has_det_bg_threshold() const;
  public:
  void clear_det_bg_threshold();
  float det_bg_threshold() const;
  void set_det_bg_threshold(float value);
  private:
  float _internal_det_bg_threshold() const;
  void _internal_set_det_bg_threshold(float value);
  public:

  // optional float det_fg_fraction = 56 [default = 0.25];
  bool has_det_fg_fraction() const;
  private:
  bool _internal_has_det_fg_fraction() const;
  public:
  void clear_det_fg_fraction();
  float det_fg_fraction() const;
  void set_det_fg_fraction(float value);
  private:
  float _internal_det_fg_fraction() const;
  void _internal_set_det_fg_fraction(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.V0LayerParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto > blobs_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > blobs_lr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > weight_decay_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr meanfile_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_det_crop_mode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr det_crop_mode_;
    ::opencv_caffe::FillerParameter* weight_filler_;
    ::opencv_caffe::FillerParameter* bias_filler_;
    ::opencv_caffe::HDF5OutputParameter* hdf5_output_param_;
    uint32_t num_output_;
    uint32_t pad_;
    uint32_t kernelsize_;
    int pool_;
    uint32_t batchsize_;
    uint32_t cropsize_;
    bool mirror_;
    bool shuffle_images_;
    uint32_t rand_skip_;
    uint32_t det_context_pad_;
    int32_t new_num_;
    int32_t new_channels_;
    int32_t new_height_;
    int32_t new_width_;
    uint32_t concat_dim_;
    bool biasterm_;
    uint32_t group_;
    uint32_t stride_;
    float dropout_ratio_;
    uint32_t local_size_;
    float alpha_;
    float beta_;
    float scale_;
    float k_;
    float det_fg_threshold_;
    float det_bg_threshold_;
    float det_fg_fraction_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PReLUParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PReLUParameter) */ {
 public:
  inline PReLUParameter() : PReLUParameter(nullptr) {}
  ~PReLUParameter() override;
  explicit PROTOBUF_CONSTEXPR PReLUParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PReLUParameter& operator=(const PReLUParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PReLUParameter& operator=(PReLUParameter&& 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 PReLUParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PReLUParameter* internal_default_instance() {
    return reinterpret_cast<const PReLUParameter*>(
               &_PReLUParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(PReLUParameter& a, PReLUParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PReLUParameter* 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(PReLUParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PReLUParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PReLUParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PReLUParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PReLUParameter& from) {
    PReLUParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PReLUParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PReLUParameter";
  }
  protected:
  explicit PReLUParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kFillerFieldNumber = 1,
    kChannelSharedFieldNumber = 2,
  };
  // optional .opencv_caffe.FillerParameter filler = 1;
  bool has_filler() const;
  private:
  bool _internal_has_filler() const;
  public:
  void clear_filler();
  const ::opencv_caffe::FillerParameter& filler() const;
  PROTOBUF_NODISCARD ::opencv_caffe::FillerParameter* release_filler();
  ::opencv_caffe::FillerParameter* mutable_filler();
  void set_allocated_filler(::opencv_caffe::FillerParameter* filler);
  private:
  const ::opencv_caffe::FillerParameter& _internal_filler() const;
  ::opencv_caffe::FillerParameter* _internal_mutable_filler();
  public:
  void unsafe_arena_set_allocated_filler(
      ::opencv_caffe::FillerParameter* filler);
  ::opencv_caffe::FillerParameter* unsafe_arena_release_filler();

  // optional bool channel_shared = 2 [default = false];
  bool has_channel_shared() const;
  private:
  bool _internal_has_channel_shared() const;
  public:
  void clear_channel_shared();
  bool channel_shared() const;
  void set_channel_shared(bool value);
  private:
  bool _internal_channel_shared() const;
  void _internal_set_channel_shared(bool value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.PReLUParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::opencv_caffe::FillerParameter* filler_;
    bool channel_shared_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class NormalizedBBox final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.NormalizedBBox) */ {
 public:
  inline NormalizedBBox() : NormalizedBBox(nullptr) {}
  ~NormalizedBBox() override;
  explicit PROTOBUF_CONSTEXPR NormalizedBBox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline NormalizedBBox& operator=(const NormalizedBBox& from) {
    CopyFrom(from);
    return *this;
  }
  inline NormalizedBBox& operator=(NormalizedBBox&& 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 NormalizedBBox& default_instance() {
    return *internal_default_instance();
  }
  static inline const NormalizedBBox* internal_default_instance() {
    return reinterpret_cast<const NormalizedBBox*>(
               &_NormalizedBBox_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(NormalizedBBox& a, NormalizedBBox& b) {
    a.Swap(&b);
  }
  inline void Swap(NormalizedBBox* 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(NormalizedBBox* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NormalizedBBox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NormalizedBBox>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NormalizedBBox& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NormalizedBBox& from) {
    NormalizedBBox::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NormalizedBBox* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.NormalizedBBox";
  }
  protected:
  explicit NormalizedBBox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kXminFieldNumber = 1,
    kYminFieldNumber = 2,
    kXmaxFieldNumber = 3,
    kYmaxFieldNumber = 4,
    kLabelFieldNumber = 5,
    kDifficultFieldNumber = 6,
    kScoreFieldNumber = 7,
    kSizeFieldNumber = 8,
  };
  // optional float xmin = 1;
  bool has_xmin() const;
  private:
  bool _internal_has_xmin() const;
  public:
  void clear_xmin();
  float xmin() const;
  void set_xmin(float value);
  private:
  float _internal_xmin() const;
  void _internal_set_xmin(float value);
  public:

  // optional float ymin = 2;
  bool has_ymin() const;
  private:
  bool _internal_has_ymin() const;
  public:
  void clear_ymin();
  float ymin() const;
  void set_ymin(float value);
  private:
  float _internal_ymin() const;
  void _internal_set_ymin(float value);
  public:

  // optional float xmax = 3;
  bool has_xmax() const;
  private:
  bool _internal_has_xmax() const;
  public:
  void clear_xmax();
  float xmax() const;
  void set_xmax(float value);
  private:
  float _internal_xmax() const;
  void _internal_set_xmax(float value);
  public:

  // optional float ymax = 4;
  bool has_ymax() const;
  private:
  bool _internal_has_ymax() const;
  public:
  void clear_ymax();
  float ymax() const;
  void set_ymax(float value);
  private:
  float _internal_ymax() const;
  void _internal_set_ymax(float value);
  public:

  // optional int32 label = 5;
  bool has_label() const;
  private:
  bool _internal_has_label() const;
  public:
  void clear_label();
  int32_t label() const;
  void set_label(int32_t value);
  private:
  int32_t _internal_label() const;
  void _internal_set_label(int32_t value);
  public:

  // optional bool difficult = 6;
  bool has_difficult() const;
  private:
  bool _internal_has_difficult() const;
  public:
  void clear_difficult();
  bool difficult() const;
  void set_difficult(bool value);
  private:
  bool _internal_difficult() const;
  void _internal_set_difficult(bool value);
  public:

  // optional float score = 7;
  bool has_score() const;
  private:
  bool _internal_has_score() const;
  public:
  void clear_score();
  float score() const;
  void set_score(float value);
  private:
  float _internal_score() const;
  void _internal_set_score(float value);
  public:

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

  // @@protoc_insertion_point(class_scope:opencv_caffe.NormalizedBBox)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float xmin_;
    float ymin_;
    float xmax_;
    float ymax_;
    int32_t label_;
    bool difficult_;
    float score_;
    float size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ROIPoolingParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ROIPoolingParameter) */ {
 public:
  inline ROIPoolingParameter() : ROIPoolingParameter(nullptr) {}
  ~ROIPoolingParameter() override;
  explicit PROTOBUF_CONSTEXPR ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ROIPoolingParameter& operator=(const ROIPoolingParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ROIPoolingParameter& operator=(ROIPoolingParameter&& 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 ROIPoolingParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ROIPoolingParameter* internal_default_instance() {
    return reinterpret_cast<const ROIPoolingParameter*>(
               &_ROIPoolingParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(ROIPoolingParameter& a, ROIPoolingParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ROIPoolingParameter* 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(ROIPoolingParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ROIPoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ROIPoolingParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ROIPoolingParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ROIPoolingParameter& from) {
    ROIPoolingParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ROIPoolingParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ROIPoolingParameter";
  }
  protected:
  explicit ROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kPooledHFieldNumber = 1,
    kPooledWFieldNumber = 2,
    kSpatialScaleFieldNumber = 3,
  };
  // optional uint32 pooled_h = 1 [default = 0];
  bool has_pooled_h() const;
  private:
  bool _internal_has_pooled_h() const;
  public:
  void clear_pooled_h();
  uint32_t pooled_h() const;
  void set_pooled_h(uint32_t value);
  private:
  uint32_t _internal_pooled_h() const;
  void _internal_set_pooled_h(uint32_t value);
  public:

  // optional uint32 pooled_w = 2 [default = 0];
  bool has_pooled_w() const;
  private:
  bool _internal_has_pooled_w() const;
  public:
  void clear_pooled_w();
  uint32_t pooled_w() const;
  void set_pooled_w(uint32_t value);
  private:
  uint32_t _internal_pooled_w() const;
  void _internal_set_pooled_w(uint32_t value);
  public:

  // optional float spatial_scale = 3 [default = 1];
  bool has_spatial_scale() const;
  private:
  bool _internal_has_spatial_scale() const;
  public:
  void clear_spatial_scale();
  float spatial_scale() const;
  void set_spatial_scale(float value);
  private:
  float _internal_spatial_scale() const;
  void _internal_set_spatial_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ROIPoolingParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t pooled_h_;
    uint32_t pooled_w_;
    float spatial_scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class ProposalParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.ProposalParameter) */ {
 public:
  inline ProposalParameter() : ProposalParameter(nullptr) {}
  ~ProposalParameter() override;
  explicit PROTOBUF_CONSTEXPR ProposalParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ProposalParameter& operator=(const ProposalParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProposalParameter& operator=(ProposalParameter&& 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 ProposalParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProposalParameter* internal_default_instance() {
    return reinterpret_cast<const ProposalParameter*>(
               &_ProposalParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  friend void swap(ProposalParameter& a, ProposalParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(ProposalParameter* 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(ProposalParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ProposalParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ProposalParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ProposalParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ProposalParameter& from) {
    ProposalParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProposalParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.ProposalParameter";
  }
  protected:
  explicit ProposalParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kRatioFieldNumber = 4,
    kScaleFieldNumber = 5,
    kFeatStrideFieldNumber = 1,
    kBaseSizeFieldNumber = 2,
    kMinSizeFieldNumber = 3,
    kPreNmsTopnFieldNumber = 6,
    kPostNmsTopnFieldNumber = 7,
    kNmsThreshFieldNumber = 8,
  };
  // repeated float ratio = 4;
  int ratio_size() const;
  private:
  int _internal_ratio_size() const;
  public:
  void clear_ratio();
  private:
  float _internal_ratio(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_ratio() const;
  void _internal_add_ratio(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_ratio();
  public:
  float ratio(int index) const;
  void set_ratio(int index, float value);
  void add_ratio(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      ratio() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_ratio();

  // repeated float scale = 5;
  int scale_size() const;
  private:
  int _internal_scale_size() const;
  public:
  void clear_scale();
  private:
  float _internal_scale(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_scale() const;
  void _internal_add_scale(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_scale();
  public:
  float scale(int index) const;
  void set_scale(int index, float value);
  void add_scale(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      scale() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_scale();

  // optional uint32 feat_stride = 1 [default = 16];
  bool has_feat_stride() const;
  private:
  bool _internal_has_feat_stride() const;
  public:
  void clear_feat_stride();
  uint32_t feat_stride() const;
  void set_feat_stride(uint32_t value);
  private:
  uint32_t _internal_feat_stride() const;
  void _internal_set_feat_stride(uint32_t value);
  public:

  // optional uint32 base_size = 2 [default = 16];
  bool has_base_size() const;
  private:
  bool _internal_has_base_size() const;
  public:
  void clear_base_size();
  uint32_t base_size() const;
  void set_base_size(uint32_t value);
  private:
  uint32_t _internal_base_size() const;
  void _internal_set_base_size(uint32_t value);
  public:

  // optional uint32 min_size = 3 [default = 16];
  bool has_min_size() const;
  private:
  bool _internal_has_min_size() const;
  public:
  void clear_min_size();
  uint32_t min_size() const;
  void set_min_size(uint32_t value);
  private:
  uint32_t _internal_min_size() const;
  void _internal_set_min_size(uint32_t value);
  public:

  // optional uint32 pre_nms_topn = 6 [default = 6000];
  bool has_pre_nms_topn() const;
  private:
  bool _internal_has_pre_nms_topn() const;
  public:
  void clear_pre_nms_topn();
  uint32_t pre_nms_topn() const;
  void set_pre_nms_topn(uint32_t value);
  private:
  uint32_t _internal_pre_nms_topn() const;
  void _internal_set_pre_nms_topn(uint32_t value);
  public:

  // optional uint32 post_nms_topn = 7 [default = 300];
  bool has_post_nms_topn() const;
  private:
  bool _internal_has_post_nms_topn() const;
  public:
  void clear_post_nms_topn();
  uint32_t post_nms_topn() const;
  void set_post_nms_topn(uint32_t value);
  private:
  uint32_t _internal_post_nms_topn() const;
  void _internal_set_post_nms_topn(uint32_t value);
  public:

  // optional float nms_thresh = 8 [default = 0.7];
  bool has_nms_thresh() const;
  private:
  bool _internal_has_nms_thresh() const;
  public:
  void clear_nms_thresh();
  float nms_thresh() const;
  void set_nms_thresh(float value);
  private:
  float _internal_nms_thresh() const;
  void _internal_set_nms_thresh(float value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.ProposalParameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > ratio_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scale_;
    uint32_t feat_stride_;
    uint32_t base_size_;
    uint32_t min_size_;
    uint32_t pre_nms_topn_;
    uint32_t post_nms_topn_;
    float nms_thresh_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// -------------------------------------------------------------------

class PSROIPoolingParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:opencv_caffe.PSROIPoolingParameter) */ {
 public:
  inline PSROIPoolingParameter() : PSROIPoolingParameter(nullptr) {}
  ~PSROIPoolingParameter() override;
  explicit PROTOBUF_CONSTEXPR PSROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PSROIPoolingParameter& operator=(const PSROIPoolingParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline PSROIPoolingParameter& operator=(PSROIPoolingParameter&& 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 PSROIPoolingParameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const PSROIPoolingParameter* internal_default_instance() {
    return reinterpret_cast<const PSROIPoolingParameter*>(
               &_PSROIPoolingParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  friend void swap(PSROIPoolingParameter& a, PSROIPoolingParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(PSROIPoolingParameter* 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(PSROIPoolingParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PSROIPoolingParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PSROIPoolingParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PSROIPoolingParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PSROIPoolingParameter& from) {
    PSROIPoolingParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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 _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PSROIPoolingParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "opencv_caffe.PSROIPoolingParameter";
  }
  protected:
  explicit PSROIPoolingParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kSpatialScaleFieldNumber = 1,
    kOutputDimFieldNumber = 2,
    kGroupSizeFieldNumber = 3,
  };
  // required float spatial_scale = 1;
  bool has_spatial_scale() const;
  private:
  bool _internal_has_spatial_scale() const;
  public:
  void clear_spatial_scale();
  float spatial_scale() const;
  void set_spatial_scale(float value);
  private:
  float _internal_spatial_scale() const;
  void _internal_set_spatial_scale(float value);
  public:

  // required int32 output_dim = 2;
  bool has_output_dim() const;
  private:
  bool _internal_has_output_dim() const;
  public:
  void clear_output_dim();
  int32_t output_dim() const;
  void set_output_dim(int32_t value);
  private:
  int32_t _internal_output_dim() const;
  void _internal_set_output_dim(int32_t value);
  public:

  // required int32 group_size = 3;
  bool has_group_size() const;
  private:
  bool _internal_has_group_size() const;
  public:
  void clear_group_size();
  int32_t group_size() const;
  void set_group_size(int32_t value);
  private:
  int32_t _internal_group_size() const;
  void _internal_set_group_size(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:opencv_caffe.PSROIPoolingParameter)
 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_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float spatial_scale_;
    int32_t output_dim_;
    int32_t group_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_opencv_2dcaffe_2eproto;
};
// ===================================================================


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

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

// repeated int64 dim = 1 [packed = true];
inline int BlobShape::_internal_dim_size() const {
  return _impl_.dim_.size();
}
inline int BlobShape::dim_size() const {
  return _internal_dim_size();
}
inline void BlobShape::clear_dim() {
  _impl_.dim_.Clear();
}
inline int64_t BlobShape::_internal_dim(int index) const {
  return _impl_.dim_.Get(index);
}
inline int64_t BlobShape::dim(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobShape.dim)
  return _internal_dim(index);
}
inline void BlobShape::set_dim(int index, int64_t value) {
  _impl_.dim_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobShape.dim)
}
inline void BlobShape::_internal_add_dim(int64_t value) {
  _impl_.dim_.Add(value);
}
inline void BlobShape::add_dim(int64_t value) {
  _internal_add_dim(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.BlobShape.dim)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
BlobShape::_internal_dim() const {
  return _impl_.dim_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
BlobShape::dim() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.BlobShape.dim)
  return _internal_dim();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
BlobShape::_internal_mutable_dim() {
  return &_impl_.dim_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
BlobShape::mutable_dim() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobShape.dim)
  return _internal_mutable_dim();
}

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

// BlobProto

// optional .opencv_caffe.BlobShape shape = 7;
inline bool BlobProto::_internal_has_shape() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
  return value;
}
inline bool BlobProto::has_shape() const {
  return _internal_has_shape();
}
inline void BlobProto::clear_shape() {
  if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::BlobShape& BlobProto::_internal_shape() const {
  const ::opencv_caffe::BlobShape* p = _impl_.shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::BlobShape&>(
      ::opencv_caffe::_BlobShape_default_instance_);
}
inline const ::opencv_caffe::BlobShape& BlobProto::shape() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.shape)
  return _internal_shape();
}
inline void BlobProto::unsafe_arena_set_allocated_shape(
    ::opencv_caffe::BlobShape* shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
  }
  _impl_.shape_ = shape;
  if (shape) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.BlobProto.shape)
}
inline ::opencv_caffe::BlobShape* BlobProto::release_shape() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::BlobShape* temp = _impl_.shape_;
  _impl_.shape_ = 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 ::opencv_caffe::BlobShape* BlobProto::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:opencv_caffe.BlobProto.shape)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::BlobShape* temp = _impl_.shape_;
  _impl_.shape_ = nullptr;
  return temp;
}
inline ::opencv_caffe::BlobShape* BlobProto::_internal_mutable_shape() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::BlobShape>(GetArenaForAllocation());
    _impl_.shape_ = p;
  }
  return _impl_.shape_;
}
inline ::opencv_caffe::BlobShape* BlobProto::mutable_shape() {
  ::opencv_caffe::BlobShape* _msg = _internal_mutable_shape();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProto.shape)
  return _msg;
}
inline void BlobProto::set_allocated_shape(::opencv_caffe::BlobShape* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.shape_;
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shape);
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.BlobProto.shape)
}

// repeated float data = 5 [packed = true];
inline int BlobProto::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int BlobProto::data_size() const {
  return _internal_data_size();
}
inline void BlobProto::clear_data() {
  _impl_.data_.Clear();
}
inline float BlobProto::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline float BlobProto::data(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.data)
  return _internal_data(index);
}
inline void BlobProto::set_data(int index, float value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.data)
}
inline void BlobProto::_internal_add_data(float value) {
  _impl_.data_.Add(value);
}
inline void BlobProto::add_data(float value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::data() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.data)
  return _internal_mutable_data();
}

// repeated float diff = 6 [packed = true];
inline int BlobProto::_internal_diff_size() const {
  return _impl_.diff_.size();
}
inline int BlobProto::diff_size() const {
  return _internal_diff_size();
}
inline void BlobProto::clear_diff() {
  _impl_.diff_.Clear();
}
inline float BlobProto::_internal_diff(int index) const {
  return _impl_.diff_.Get(index);
}
inline float BlobProto::diff(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.diff)
  return _internal_diff(index);
}
inline void BlobProto::set_diff(int index, float value) {
  _impl_.diff_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.diff)
}
inline void BlobProto::_internal_add_diff(float value) {
  _impl_.diff_.Add(value);
}
inline void BlobProto::add_diff(float value) {
  _internal_add_diff(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.diff)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::_internal_diff() const {
  return _impl_.diff_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BlobProto::diff() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.diff)
  return _internal_diff();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::_internal_mutable_diff() {
  return &_impl_.diff_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BlobProto::mutable_diff() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.diff)
  return _internal_mutable_diff();
}

// repeated double double_data = 8 [packed = true];
inline int BlobProto::_internal_double_data_size() const {
  return _impl_.double_data_.size();
}
inline int BlobProto::double_data_size() const {
  return _internal_double_data_size();
}
inline void BlobProto::clear_double_data() {
  _impl_.double_data_.Clear();
}
inline double BlobProto::_internal_double_data(int index) const {
  return _impl_.double_data_.Get(index);
}
inline double BlobProto::double_data(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.double_data)
  return _internal_double_data(index);
}
inline void BlobProto::set_double_data(int index, double value) {
  _impl_.double_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.double_data)
}
inline void BlobProto::_internal_add_double_data(double value) {
  _impl_.double_data_.Add(value);
}
inline void BlobProto::add_double_data(double value) {
  _internal_add_double_data(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.double_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::_internal_double_data() const {
  return _impl_.double_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::double_data() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.double_data)
  return _internal_double_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::_internal_mutable_double_data() {
  return &_impl_.double_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::mutable_double_data() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.double_data)
  return _internal_mutable_double_data();
}

// repeated double double_diff = 9 [packed = true];
inline int BlobProto::_internal_double_diff_size() const {
  return _impl_.double_diff_.size();
}
inline int BlobProto::double_diff_size() const {
  return _internal_double_diff_size();
}
inline void BlobProto::clear_double_diff() {
  _impl_.double_diff_.Clear();
}
inline double BlobProto::_internal_double_diff(int index) const {
  return _impl_.double_diff_.Get(index);
}
inline double BlobProto::double_diff(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.double_diff)
  return _internal_double_diff(index);
}
inline void BlobProto::set_double_diff(int index, double value) {
  _impl_.double_diff_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.double_diff)
}
inline void BlobProto::_internal_add_double_diff(double value) {
  _impl_.double_diff_.Add(value);
}
inline void BlobProto::add_double_diff(double value) {
  _internal_add_double_diff(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.BlobProto.double_diff)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::_internal_double_diff() const {
  return _impl_.double_diff_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BlobProto::double_diff() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.BlobProto.double_diff)
  return _internal_double_diff();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::_internal_mutable_double_diff() {
  return &_impl_.double_diff_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BlobProto::mutable_double_diff() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProto.double_diff)
  return _internal_mutable_double_diff();
}

// optional .opencv_caffe.Type raw_data_type = 10;
inline bool BlobProto::_internal_has_raw_data_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool BlobProto::has_raw_data_type() const {
  return _internal_has_raw_data_type();
}
inline void BlobProto::clear_raw_data_type() {
  _impl_.raw_data_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::opencv_caffe::Type BlobProto::_internal_raw_data_type() const {
  return static_cast< ::opencv_caffe::Type >(_impl_.raw_data_type_);
}
inline ::opencv_caffe::Type BlobProto::raw_data_type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.raw_data_type)
  return _internal_raw_data_type();
}
inline void BlobProto::_internal_set_raw_data_type(::opencv_caffe::Type value) {
  assert(::opencv_caffe::Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.raw_data_type_ = value;
}
inline void BlobProto::set_raw_data_type(::opencv_caffe::Type value) {
  _internal_set_raw_data_type(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.raw_data_type)
}

// optional bytes raw_data = 12 [packed = false];
inline bool BlobProto::_internal_has_raw_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BlobProto::has_raw_data() const {
  return _internal_has_raw_data();
}
inline void BlobProto::clear_raw_data() {
  _impl_.raw_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& BlobProto::raw_data() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.raw_data)
  return _internal_raw_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BlobProto::set_raw_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.raw_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.raw_data)
}
inline std::string* BlobProto::mutable_raw_data() {
  std::string* _s = _internal_mutable_raw_data();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProto.raw_data)
  return _s;
}
inline const std::string& BlobProto::_internal_raw_data() const {
  return _impl_.raw_data_.Get();
}
inline void BlobProto::_internal_set_raw_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.raw_data_.Set(value, GetArenaForAllocation());
}
inline std::string* BlobProto::_internal_mutable_raw_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.raw_data_.Mutable(GetArenaForAllocation());
}
inline std::string* BlobProto::release_raw_data() {
  // @@protoc_insertion_point(field_release:opencv_caffe.BlobProto.raw_data)
  if (!_internal_has_raw_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.raw_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.raw_data_.IsDefault()) {
    _impl_.raw_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void BlobProto::set_allocated_raw_data(std::string* raw_data) {
  if (raw_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.raw_data_.SetAllocated(raw_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.raw_data_.IsDefault()) {
    _impl_.raw_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.BlobProto.raw_data)
}

// optional int32 num = 1 [default = 0];
inline bool BlobProto::_internal_has_num() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BlobProto::has_num() const {
  return _internal_has_num();
}
inline void BlobProto::clear_num() {
  _impl_.num_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t BlobProto::_internal_num() const {
  return _impl_.num_;
}
inline int32_t BlobProto::num() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.num)
  return _internal_num();
}
inline void BlobProto::_internal_set_num(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_ = value;
}
inline void BlobProto::set_num(int32_t value) {
  _internal_set_num(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.num)
}

// optional int32 channels = 2 [default = 0];
inline bool BlobProto::_internal_has_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool BlobProto::has_channels() const {
  return _internal_has_channels();
}
inline void BlobProto::clear_channels() {
  _impl_.channels_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t BlobProto::_internal_channels() const {
  return _impl_.channels_;
}
inline int32_t BlobProto::channels() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.channels)
  return _internal_channels();
}
inline void BlobProto::_internal_set_channels(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.channels_ = value;
}
inline void BlobProto::set_channels(int32_t value) {
  _internal_set_channels(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.channels)
}

// optional int32 height = 3 [default = 0];
inline bool BlobProto::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool BlobProto::has_height() const {
  return _internal_has_height();
}
inline void BlobProto::clear_height() {
  _impl_.height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t BlobProto::_internal_height() const {
  return _impl_.height_;
}
inline int32_t BlobProto::height() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.height)
  return _internal_height();
}
inline void BlobProto::_internal_set_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.height_ = value;
}
inline void BlobProto::set_height(int32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.height)
}

// optional int32 width = 4 [default = 0];
inline bool BlobProto::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool BlobProto::has_width() const {
  return _internal_has_width();
}
inline void BlobProto::clear_width() {
  _impl_.width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t BlobProto::_internal_width() const {
  return _impl_.width_;
}
inline int32_t BlobProto::width() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProto.width)
  return _internal_width();
}
inline void BlobProto::_internal_set_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.width_ = value;
}
inline void BlobProto::set_width(int32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BlobProto.width)
}

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

// BlobProtoVector

// repeated .opencv_caffe.BlobProto blobs = 1;
inline int BlobProtoVector::_internal_blobs_size() const {
  return _impl_.blobs_.size();
}
inline int BlobProtoVector::blobs_size() const {
  return _internal_blobs_size();
}
inline void BlobProtoVector::clear_blobs() {
  _impl_.blobs_.Clear();
}
inline ::opencv_caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.BlobProtoVector.blobs)
  return _impl_.blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
BlobProtoVector::mutable_blobs() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.BlobProtoVector.blobs)
  return &_impl_.blobs_;
}
inline const ::opencv_caffe::BlobProto& BlobProtoVector::_internal_blobs(int index) const {
  return _impl_.blobs_.Get(index);
}
inline const ::opencv_caffe::BlobProto& BlobProtoVector::blobs(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BlobProtoVector.blobs)
  return _internal_blobs(index);
}
inline ::opencv_caffe::BlobProto* BlobProtoVector::_internal_add_blobs() {
  return _impl_.blobs_.Add();
}
inline ::opencv_caffe::BlobProto* BlobProtoVector::add_blobs() {
  ::opencv_caffe::BlobProto* _add = _internal_add_blobs();
  // @@protoc_insertion_point(field_add:opencv_caffe.BlobProtoVector.blobs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
BlobProtoVector::blobs() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.BlobProtoVector.blobs)
  return _impl_.blobs_;
}

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

// PermuteParameter

// repeated uint32 order = 1;
inline int PermuteParameter::_internal_order_size() const {
  return _impl_.order_.size();
}
inline int PermuteParameter::order_size() const {
  return _internal_order_size();
}
inline void PermuteParameter::clear_order() {
  _impl_.order_.Clear();
}
inline uint32_t PermuteParameter::_internal_order(int index) const {
  return _impl_.order_.Get(index);
}
inline uint32_t PermuteParameter::order(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PermuteParameter.order)
  return _internal_order(index);
}
inline void PermuteParameter::set_order(int index, uint32_t value) {
  _impl_.order_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PermuteParameter.order)
}
inline void PermuteParameter::_internal_add_order(uint32_t value) {
  _impl_.order_.Add(value);
}
inline void PermuteParameter::add_order(uint32_t value) {
  _internal_add_order(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PermuteParameter.order)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
PermuteParameter::_internal_order() const {
  return _impl_.order_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
PermuteParameter::order() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PermuteParameter.order)
  return _internal_order();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
PermuteParameter::_internal_mutable_order() {
  return &_impl_.order_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
PermuteParameter::mutable_order() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PermuteParameter.order)
  return _internal_mutable_order();
}

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

// NormalizeBBoxParameter

// optional bool across_spatial = 1 [default = true];
inline bool NormalizeBBoxParameter::_internal_has_across_spatial() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NormalizeBBoxParameter::has_across_spatial() const {
  return _internal_has_across_spatial();
}
inline void NormalizeBBoxParameter::clear_across_spatial() {
  _impl_.across_spatial_ = true;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool NormalizeBBoxParameter::_internal_across_spatial() const {
  return _impl_.across_spatial_;
}
inline bool NormalizeBBoxParameter::across_spatial() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.across_spatial)
  return _internal_across_spatial();
}
inline void NormalizeBBoxParameter::_internal_set_across_spatial(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.across_spatial_ = value;
}
inline void NormalizeBBoxParameter::set_across_spatial(bool value) {
  _internal_set_across_spatial(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.across_spatial)
}

// optional .opencv_caffe.FillerParameter scale_filler = 2;
inline bool NormalizeBBoxParameter::_internal_has_scale_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.scale_filler_ != nullptr);
  return value;
}
inline bool NormalizeBBoxParameter::has_scale_filler() const {
  return _internal_has_scale_filler();
}
inline void NormalizeBBoxParameter::clear_scale_filler() {
  if (_impl_.scale_filler_ != nullptr) _impl_.scale_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& NormalizeBBoxParameter::_internal_scale_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.scale_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& NormalizeBBoxParameter::scale_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.scale_filler)
  return _internal_scale_filler();
}
inline void NormalizeBBoxParameter::unsafe_arena_set_allocated_scale_filler(
    ::opencv_caffe::FillerParameter* scale_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.scale_filler_);
  }
  _impl_.scale_filler_ = scale_filler;
  if (scale_filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.NormalizeBBoxParameter.scale_filler)
}
inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::release_scale_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.scale_filler_;
  _impl_.scale_filler_ = 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 ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::unsafe_arena_release_scale_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.NormalizeBBoxParameter.scale_filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.scale_filler_;
  _impl_.scale_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::_internal_mutable_scale_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.scale_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.scale_filler_ = p;
  }
  return _impl_.scale_filler_;
}
inline ::opencv_caffe::FillerParameter* NormalizeBBoxParameter::mutable_scale_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_scale_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NormalizeBBoxParameter.scale_filler)
  return _msg;
}
inline void NormalizeBBoxParameter::set_allocated_scale_filler(::opencv_caffe::FillerParameter* scale_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.scale_filler_;
  }
  if (scale_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(scale_filler);
    if (message_arena != submessage_arena) {
      scale_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scale_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.scale_filler_ = scale_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.NormalizeBBoxParameter.scale_filler)
}

// optional bool channel_shared = 3 [default = true];
inline bool NormalizeBBoxParameter::_internal_has_channel_shared() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NormalizeBBoxParameter::has_channel_shared() const {
  return _internal_has_channel_shared();
}
inline void NormalizeBBoxParameter::clear_channel_shared() {
  _impl_.channel_shared_ = true;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool NormalizeBBoxParameter::_internal_channel_shared() const {
  return _impl_.channel_shared_;
}
inline bool NormalizeBBoxParameter::channel_shared() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.channel_shared)
  return _internal_channel_shared();
}
inline void NormalizeBBoxParameter::_internal_set_channel_shared(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.channel_shared_ = value;
}
inline void NormalizeBBoxParameter::set_channel_shared(bool value) {
  _internal_set_channel_shared(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.channel_shared)
}

// optional float eps = 4 [default = 1e-10];
inline bool NormalizeBBoxParameter::_internal_has_eps() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NormalizeBBoxParameter::has_eps() const {
  return _internal_has_eps();
}
inline void NormalizeBBoxParameter::clear_eps() {
  _impl_.eps_ = 1e-10f;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float NormalizeBBoxParameter::_internal_eps() const {
  return _impl_.eps_;
}
inline float NormalizeBBoxParameter::eps() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizeBBoxParameter.eps)
  return _internal_eps();
}
inline void NormalizeBBoxParameter::_internal_set_eps(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.eps_ = value;
}
inline void NormalizeBBoxParameter::set_eps(float value) {
  _internal_set_eps(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizeBBoxParameter.eps)
}

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

// PriorBoxParameter

// repeated float min_size = 1;
inline int PriorBoxParameter::_internal_min_size_size() const {
  return _impl_.min_size_.size();
}
inline int PriorBoxParameter::min_size_size() const {
  return _internal_min_size_size();
}
inline void PriorBoxParameter::clear_min_size() {
  _impl_.min_size_.Clear();
}
inline float PriorBoxParameter::_internal_min_size(int index) const {
  return _impl_.min_size_.Get(index);
}
inline float PriorBoxParameter::min_size(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.min_size)
  return _internal_min_size(index);
}
inline void PriorBoxParameter::set_min_size(int index, float value) {
  _impl_.min_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.min_size)
}
inline void PriorBoxParameter::_internal_add_min_size(float value) {
  _impl_.min_size_.Add(value);
}
inline void PriorBoxParameter::add_min_size(float value) {
  _internal_add_min_size(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.min_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_min_size() const {
  return _impl_.min_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::min_size() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.min_size)
  return _internal_min_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_min_size() {
  return &_impl_.min_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_min_size() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.min_size)
  return _internal_mutable_min_size();
}

// repeated float max_size = 2;
inline int PriorBoxParameter::_internal_max_size_size() const {
  return _impl_.max_size_.size();
}
inline int PriorBoxParameter::max_size_size() const {
  return _internal_max_size_size();
}
inline void PriorBoxParameter::clear_max_size() {
  _impl_.max_size_.Clear();
}
inline float PriorBoxParameter::_internal_max_size(int index) const {
  return _impl_.max_size_.Get(index);
}
inline float PriorBoxParameter::max_size(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.max_size)
  return _internal_max_size(index);
}
inline void PriorBoxParameter::set_max_size(int index, float value) {
  _impl_.max_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.max_size)
}
inline void PriorBoxParameter::_internal_add_max_size(float value) {
  _impl_.max_size_.Add(value);
}
inline void PriorBoxParameter::add_max_size(float value) {
  _internal_add_max_size(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.max_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_max_size() const {
  return _impl_.max_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::max_size() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.max_size)
  return _internal_max_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_max_size() {
  return &_impl_.max_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_max_size() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.max_size)
  return _internal_mutable_max_size();
}

// repeated float aspect_ratio = 3;
inline int PriorBoxParameter::_internal_aspect_ratio_size() const {
  return _impl_.aspect_ratio_.size();
}
inline int PriorBoxParameter::aspect_ratio_size() const {
  return _internal_aspect_ratio_size();
}
inline void PriorBoxParameter::clear_aspect_ratio() {
  _impl_.aspect_ratio_.Clear();
}
inline float PriorBoxParameter::_internal_aspect_ratio(int index) const {
  return _impl_.aspect_ratio_.Get(index);
}
inline float PriorBoxParameter::aspect_ratio(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.aspect_ratio)
  return _internal_aspect_ratio(index);
}
inline void PriorBoxParameter::set_aspect_ratio(int index, float value) {
  _impl_.aspect_ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.aspect_ratio)
}
inline void PriorBoxParameter::_internal_add_aspect_ratio(float value) {
  _impl_.aspect_ratio_.Add(value);
}
inline void PriorBoxParameter::add_aspect_ratio(float value) {
  _internal_add_aspect_ratio(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.aspect_ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_aspect_ratio() const {
  return _impl_.aspect_ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::aspect_ratio() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.aspect_ratio)
  return _internal_aspect_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_aspect_ratio() {
  return &_impl_.aspect_ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_aspect_ratio() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.aspect_ratio)
  return _internal_mutable_aspect_ratio();
}

// optional bool flip = 4 [default = true];
inline bool PriorBoxParameter::_internal_has_flip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_flip() const {
  return _internal_has_flip();
}
inline void PriorBoxParameter::clear_flip() {
  _impl_.flip_ = true;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool PriorBoxParameter::_internal_flip() const {
  return _impl_.flip_;
}
inline bool PriorBoxParameter::flip() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.flip)
  return _internal_flip();
}
inline void PriorBoxParameter::_internal_set_flip(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.flip_ = value;
}
inline void PriorBoxParameter::set_flip(bool value) {
  _internal_set_flip(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.flip)
}

// optional bool clip = 5 [default = true];
inline bool PriorBoxParameter::_internal_has_clip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_clip() const {
  return _internal_has_clip();
}
inline void PriorBoxParameter::clear_clip() {
  _impl_.clip_ = true;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool PriorBoxParameter::_internal_clip() const {
  return _impl_.clip_;
}
inline bool PriorBoxParameter::clip() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.clip)
  return _internal_clip();
}
inline void PriorBoxParameter::_internal_set_clip(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.clip_ = value;
}
inline void PriorBoxParameter::set_clip(bool value) {
  _internal_set_clip(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.clip)
}

// repeated float variance = 6;
inline int PriorBoxParameter::_internal_variance_size() const {
  return _impl_.variance_.size();
}
inline int PriorBoxParameter::variance_size() const {
  return _internal_variance_size();
}
inline void PriorBoxParameter::clear_variance() {
  _impl_.variance_.Clear();
}
inline float PriorBoxParameter::_internal_variance(int index) const {
  return _impl_.variance_.Get(index);
}
inline float PriorBoxParameter::variance(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.variance)
  return _internal_variance(index);
}
inline void PriorBoxParameter::set_variance(int index, float value) {
  _impl_.variance_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.variance)
}
inline void PriorBoxParameter::_internal_add_variance(float value) {
  _impl_.variance_.Add(value);
}
inline void PriorBoxParameter::add_variance(float value) {
  _internal_add_variance(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.variance)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_variance() const {
  return _impl_.variance_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::variance() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.variance)
  return _internal_variance();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_variance() {
  return &_impl_.variance_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_variance() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.variance)
  return _internal_mutable_variance();
}

// optional uint32 img_size = 7;
inline bool PriorBoxParameter::_internal_has_img_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_img_size() const {
  return _internal_has_img_size();
}
inline void PriorBoxParameter::clear_img_size() {
  _impl_.img_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t PriorBoxParameter::_internal_img_size() const {
  return _impl_.img_size_;
}
inline uint32_t PriorBoxParameter::img_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_size)
  return _internal_img_size();
}
inline void PriorBoxParameter::_internal_set_img_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.img_size_ = value;
}
inline void PriorBoxParameter::set_img_size(uint32_t value) {
  _internal_set_img_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_size)
}

// optional uint32 img_h = 8;
inline bool PriorBoxParameter::_internal_has_img_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_img_h() const {
  return _internal_has_img_h();
}
inline void PriorBoxParameter::clear_img_h() {
  _impl_.img_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t PriorBoxParameter::_internal_img_h() const {
  return _impl_.img_h_;
}
inline uint32_t PriorBoxParameter::img_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_h)
  return _internal_img_h();
}
inline void PriorBoxParameter::_internal_set_img_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.img_h_ = value;
}
inline void PriorBoxParameter::set_img_h(uint32_t value) {
  _internal_set_img_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_h)
}

// optional uint32 img_w = 9;
inline bool PriorBoxParameter::_internal_has_img_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_img_w() const {
  return _internal_has_img_w();
}
inline void PriorBoxParameter::clear_img_w() {
  _impl_.img_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t PriorBoxParameter::_internal_img_w() const {
  return _impl_.img_w_;
}
inline uint32_t PriorBoxParameter::img_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.img_w)
  return _internal_img_w();
}
inline void PriorBoxParameter::_internal_set_img_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.img_w_ = value;
}
inline void PriorBoxParameter::set_img_w(uint32_t value) {
  _internal_set_img_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.img_w)
}

// optional float step = 10;
inline bool PriorBoxParameter::_internal_has_step() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_step() const {
  return _internal_has_step();
}
inline void PriorBoxParameter::clear_step() {
  _impl_.step_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float PriorBoxParameter::_internal_step() const {
  return _impl_.step_;
}
inline float PriorBoxParameter::step() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step)
  return _internal_step();
}
inline void PriorBoxParameter::_internal_set_step(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.step_ = value;
}
inline void PriorBoxParameter::set_step(float value) {
  _internal_set_step(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step)
}

// optional float step_h = 11;
inline bool PriorBoxParameter::_internal_has_step_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_step_h() const {
  return _internal_has_step_h();
}
inline void PriorBoxParameter::clear_step_h() {
  _impl_.step_h_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float PriorBoxParameter::_internal_step_h() const {
  return _impl_.step_h_;
}
inline float PriorBoxParameter::step_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step_h)
  return _internal_step_h();
}
inline void PriorBoxParameter::_internal_set_step_h(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.step_h_ = value;
}
inline void PriorBoxParameter::set_step_h(float value) {
  _internal_set_step_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step_h)
}

// optional float step_w = 12;
inline bool PriorBoxParameter::_internal_has_step_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_step_w() const {
  return _internal_has_step_w();
}
inline void PriorBoxParameter::clear_step_w() {
  _impl_.step_w_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float PriorBoxParameter::_internal_step_w() const {
  return _impl_.step_w_;
}
inline float PriorBoxParameter::step_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.step_w)
  return _internal_step_w();
}
inline void PriorBoxParameter::_internal_set_step_w(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.step_w_ = value;
}
inline void PriorBoxParameter::set_step_w(float value) {
  _internal_set_step_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.step_w)
}

// optional float offset = 13 [default = 0.5];
inline bool PriorBoxParameter::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool PriorBoxParameter::has_offset() const {
  return _internal_has_offset();
}
inline void PriorBoxParameter::clear_offset() {
  _impl_.offset_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float PriorBoxParameter::_internal_offset() const {
  return _impl_.offset_;
}
inline float PriorBoxParameter::offset() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset)
  return _internal_offset();
}
inline void PriorBoxParameter::_internal_set_offset(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.offset_ = value;
}
inline void PriorBoxParameter::set_offset(float value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset)
}

// repeated float offset_h = 14;
inline int PriorBoxParameter::_internal_offset_h_size() const {
  return _impl_.offset_h_.size();
}
inline int PriorBoxParameter::offset_h_size() const {
  return _internal_offset_h_size();
}
inline void PriorBoxParameter::clear_offset_h() {
  _impl_.offset_h_.Clear();
}
inline float PriorBoxParameter::_internal_offset_h(int index) const {
  return _impl_.offset_h_.Get(index);
}
inline float PriorBoxParameter::offset_h(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset_h)
  return _internal_offset_h(index);
}
inline void PriorBoxParameter::set_offset_h(int index, float value) {
  _impl_.offset_h_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset_h)
}
inline void PriorBoxParameter::_internal_add_offset_h(float value) {
  _impl_.offset_h_.Add(value);
}
inline void PriorBoxParameter::add_offset_h(float value) {
  _internal_add_offset_h(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.offset_h)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_offset_h() const {
  return _impl_.offset_h_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::offset_h() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.offset_h)
  return _internal_offset_h();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_offset_h() {
  return &_impl_.offset_h_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_offset_h() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.offset_h)
  return _internal_mutable_offset_h();
}

// repeated float offset_w = 15;
inline int PriorBoxParameter::_internal_offset_w_size() const {
  return _impl_.offset_w_.size();
}
inline int PriorBoxParameter::offset_w_size() const {
  return _internal_offset_w_size();
}
inline void PriorBoxParameter::clear_offset_w() {
  _impl_.offset_w_.Clear();
}
inline float PriorBoxParameter::_internal_offset_w(int index) const {
  return _impl_.offset_w_.Get(index);
}
inline float PriorBoxParameter::offset_w(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.offset_w)
  return _internal_offset_w(index);
}
inline void PriorBoxParameter::set_offset_w(int index, float value) {
  _impl_.offset_w_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.offset_w)
}
inline void PriorBoxParameter::_internal_add_offset_w(float value) {
  _impl_.offset_w_.Add(value);
}
inline void PriorBoxParameter::add_offset_w(float value) {
  _internal_add_offset_w(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.offset_w)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_offset_w() const {
  return _impl_.offset_w_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::offset_w() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.offset_w)
  return _internal_offset_w();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_offset_w() {
  return &_impl_.offset_w_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_offset_w() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.offset_w)
  return _internal_mutable_offset_w();
}

// repeated float width = 16;
inline int PriorBoxParameter::_internal_width_size() const {
  return _impl_.width_.size();
}
inline int PriorBoxParameter::width_size() const {
  return _internal_width_size();
}
inline void PriorBoxParameter::clear_width() {
  _impl_.width_.Clear();
}
inline float PriorBoxParameter::_internal_width(int index) const {
  return _impl_.width_.Get(index);
}
inline float PriorBoxParameter::width(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.width)
  return _internal_width(index);
}
inline void PriorBoxParameter::set_width(int index, float value) {
  _impl_.width_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.width)
}
inline void PriorBoxParameter::_internal_add_width(float value) {
  _impl_.width_.Add(value);
}
inline void PriorBoxParameter::add_width(float value) {
  _internal_add_width(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.width)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_width() const {
  return _impl_.width_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::width() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.width)
  return _internal_width();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_width() {
  return &_impl_.width_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_width() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.width)
  return _internal_mutable_width();
}

// repeated float height = 17;
inline int PriorBoxParameter::_internal_height_size() const {
  return _impl_.height_.size();
}
inline int PriorBoxParameter::height_size() const {
  return _internal_height_size();
}
inline void PriorBoxParameter::clear_height() {
  _impl_.height_.Clear();
}
inline float PriorBoxParameter::_internal_height(int index) const {
  return _impl_.height_.Get(index);
}
inline float PriorBoxParameter::height(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PriorBoxParameter.height)
  return _internal_height(index);
}
inline void PriorBoxParameter::set_height(int index, float value) {
  _impl_.height_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PriorBoxParameter.height)
}
inline void PriorBoxParameter::_internal_add_height(float value) {
  _impl_.height_.Add(value);
}
inline void PriorBoxParameter::add_height(float value) {
  _internal_add_height(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.PriorBoxParameter.height)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::_internal_height() const {
  return _impl_.height_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
PriorBoxParameter::height() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.PriorBoxParameter.height)
  return _internal_height();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::_internal_mutable_height() {
  return &_impl_.height_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
PriorBoxParameter::mutable_height() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.PriorBoxParameter.height)
  return _internal_mutable_height();
}

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

// DetectionOutputParameter

// optional uint32 num_classes = 1;
inline bool DetectionOutputParameter::_internal_has_num_classes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_num_classes() const {
  return _internal_has_num_classes();
}
inline void DetectionOutputParameter::clear_num_classes() {
  _impl_.num_classes_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t DetectionOutputParameter::_internal_num_classes() const {
  return _impl_.num_classes_;
}
inline uint32_t DetectionOutputParameter::num_classes() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.num_classes)
  return _internal_num_classes();
}
inline void DetectionOutputParameter::_internal_set_num_classes(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_classes_ = value;
}
inline void DetectionOutputParameter::set_num_classes(uint32_t value) {
  _internal_set_num_classes(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.num_classes)
}

// optional bool share_location = 2 [default = true];
inline bool DetectionOutputParameter::_internal_has_share_location() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_share_location() const {
  return _internal_has_share_location();
}
inline void DetectionOutputParameter::clear_share_location() {
  _impl_.share_location_ = true;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool DetectionOutputParameter::_internal_share_location() const {
  return _impl_.share_location_;
}
inline bool DetectionOutputParameter::share_location() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.share_location)
  return _internal_share_location();
}
inline void DetectionOutputParameter::_internal_set_share_location(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.share_location_ = value;
}
inline void DetectionOutputParameter::set_share_location(bool value) {
  _internal_set_share_location(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.share_location)
}

// optional int32 background_label_id = 3 [default = 0];
inline bool DetectionOutputParameter::_internal_has_background_label_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_background_label_id() const {
  return _internal_has_background_label_id();
}
inline void DetectionOutputParameter::clear_background_label_id() {
  _impl_.background_label_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t DetectionOutputParameter::_internal_background_label_id() const {
  return _impl_.background_label_id_;
}
inline int32_t DetectionOutputParameter::background_label_id() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.background_label_id)
  return _internal_background_label_id();
}
inline void DetectionOutputParameter::_internal_set_background_label_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.background_label_id_ = value;
}
inline void DetectionOutputParameter::set_background_label_id(int32_t value) {
  _internal_set_background_label_id(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.background_label_id)
}

// optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
inline bool DetectionOutputParameter::_internal_has_nms_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.nms_param_ != nullptr);
  return value;
}
inline bool DetectionOutputParameter::has_nms_param() const {
  return _internal_has_nms_param();
}
inline void DetectionOutputParameter::clear_nms_param() {
  if (_impl_.nms_param_ != nullptr) _impl_.nms_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::_internal_nms_param() const {
  const ::opencv_caffe::NonMaximumSuppressionParameter* p = _impl_.nms_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::NonMaximumSuppressionParameter&>(
      ::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_);
}
inline const ::opencv_caffe::NonMaximumSuppressionParameter& DetectionOutputParameter::nms_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.nms_param)
  return _internal_nms_param();
}
inline void DetectionOutputParameter::unsafe_arena_set_allocated_nms_param(
    ::opencv_caffe::NonMaximumSuppressionParameter* nms_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nms_param_);
  }
  _impl_.nms_param_ = nms_param;
  if (nms_param) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.DetectionOutputParameter.nms_param)
}
inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::release_nms_param() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::NonMaximumSuppressionParameter* temp = _impl_.nms_param_;
  _impl_.nms_param_ = 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 ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::unsafe_arena_release_nms_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.DetectionOutputParameter.nms_param)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::NonMaximumSuppressionParameter* temp = _impl_.nms_param_;
  _impl_.nms_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::_internal_mutable_nms_param() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.nms_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::NonMaximumSuppressionParameter>(GetArenaForAllocation());
    _impl_.nms_param_ = p;
  }
  return _impl_.nms_param_;
}
inline ::opencv_caffe::NonMaximumSuppressionParameter* DetectionOutputParameter::mutable_nms_param() {
  ::opencv_caffe::NonMaximumSuppressionParameter* _msg = _internal_mutable_nms_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.DetectionOutputParameter.nms_param)
  return _msg;
}
inline void DetectionOutputParameter::set_allocated_nms_param(::opencv_caffe::NonMaximumSuppressionParameter* nms_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.nms_param_;
  }
  if (nms_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nms_param);
    if (message_arena != submessage_arena) {
      nms_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nms_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.nms_param_ = nms_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.DetectionOutputParameter.nms_param)
}

// optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
inline bool DetectionOutputParameter::_internal_has_save_output_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.save_output_param_ != nullptr);
  return value;
}
inline bool DetectionOutputParameter::has_save_output_param() const {
  return _internal_has_save_output_param();
}
inline void DetectionOutputParameter::clear_save_output_param() {
  if (_impl_.save_output_param_ != nullptr) _impl_.save_output_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::SaveOutputParameter& DetectionOutputParameter::_internal_save_output_param() const {
  const ::opencv_caffe::SaveOutputParameter* p = _impl_.save_output_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SaveOutputParameter&>(
      ::opencv_caffe::_SaveOutputParameter_default_instance_);
}
inline const ::opencv_caffe::SaveOutputParameter& DetectionOutputParameter::save_output_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.save_output_param)
  return _internal_save_output_param();
}
inline void DetectionOutputParameter::unsafe_arena_set_allocated_save_output_param(
    ::opencv_caffe::SaveOutputParameter* save_output_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.save_output_param_);
  }
  _impl_.save_output_param_ = save_output_param;
  if (save_output_param) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.DetectionOutputParameter.save_output_param)
}
inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::release_save_output_param() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::SaveOutputParameter* temp = _impl_.save_output_param_;
  _impl_.save_output_param_ = 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 ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::unsafe_arena_release_save_output_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.DetectionOutputParameter.save_output_param)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::SaveOutputParameter* temp = _impl_.save_output_param_;
  _impl_.save_output_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::_internal_mutable_save_output_param() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.save_output_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SaveOutputParameter>(GetArenaForAllocation());
    _impl_.save_output_param_ = p;
  }
  return _impl_.save_output_param_;
}
inline ::opencv_caffe::SaveOutputParameter* DetectionOutputParameter::mutable_save_output_param() {
  ::opencv_caffe::SaveOutputParameter* _msg = _internal_mutable_save_output_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.DetectionOutputParameter.save_output_param)
  return _msg;
}
inline void DetectionOutputParameter::set_allocated_save_output_param(::opencv_caffe::SaveOutputParameter* save_output_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.save_output_param_;
  }
  if (save_output_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(save_output_param);
    if (message_arena != submessage_arena) {
      save_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, save_output_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.save_output_param_ = save_output_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.DetectionOutputParameter.save_output_param)
}

// optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
inline bool DetectionOutputParameter::_internal_has_code_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_code_type() const {
  return _internal_has_code_type();
}
inline void DetectionOutputParameter::clear_code_type() {
  _impl_.code_type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline ::opencv_caffe::PriorBoxParameter_CodeType DetectionOutputParameter::_internal_code_type() const {
  return static_cast< ::opencv_caffe::PriorBoxParameter_CodeType >(_impl_.code_type_);
}
inline ::opencv_caffe::PriorBoxParameter_CodeType DetectionOutputParameter::code_type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.code_type)
  return _internal_code_type();
}
inline void DetectionOutputParameter::_internal_set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value) {
  assert(::opencv_caffe::PriorBoxParameter_CodeType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.code_type_ = value;
}
inline void DetectionOutputParameter::set_code_type(::opencv_caffe::PriorBoxParameter_CodeType value) {
  _internal_set_code_type(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.code_type)
}

// optional bool variance_encoded_in_target = 8 [default = false];
inline bool DetectionOutputParameter::_internal_has_variance_encoded_in_target() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_variance_encoded_in_target() const {
  return _internal_has_variance_encoded_in_target();
}
inline void DetectionOutputParameter::clear_variance_encoded_in_target() {
  _impl_.variance_encoded_in_target_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool DetectionOutputParameter::_internal_variance_encoded_in_target() const {
  return _impl_.variance_encoded_in_target_;
}
inline bool DetectionOutputParameter::variance_encoded_in_target() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.variance_encoded_in_target)
  return _internal_variance_encoded_in_target();
}
inline void DetectionOutputParameter::_internal_set_variance_encoded_in_target(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.variance_encoded_in_target_ = value;
}
inline void DetectionOutputParameter::set_variance_encoded_in_target(bool value) {
  _internal_set_variance_encoded_in_target(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.variance_encoded_in_target)
}

// optional int32 keep_top_k = 7 [default = -1];
inline bool DetectionOutputParameter::_internal_has_keep_top_k() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_keep_top_k() const {
  return _internal_has_keep_top_k();
}
inline void DetectionOutputParameter::clear_keep_top_k() {
  _impl_.keep_top_k_ = -1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t DetectionOutputParameter::_internal_keep_top_k() const {
  return _impl_.keep_top_k_;
}
inline int32_t DetectionOutputParameter::keep_top_k() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.keep_top_k)
  return _internal_keep_top_k();
}
inline void DetectionOutputParameter::_internal_set_keep_top_k(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.keep_top_k_ = value;
}
inline void DetectionOutputParameter::set_keep_top_k(int32_t value) {
  _internal_set_keep_top_k(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.keep_top_k)
}

// optional float confidence_threshold = 9;
inline bool DetectionOutputParameter::_internal_has_confidence_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_confidence_threshold() const {
  return _internal_has_confidence_threshold();
}
inline void DetectionOutputParameter::clear_confidence_threshold() {
  _impl_.confidence_threshold_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float DetectionOutputParameter::_internal_confidence_threshold() const {
  return _impl_.confidence_threshold_;
}
inline float DetectionOutputParameter::confidence_threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.confidence_threshold)
  return _internal_confidence_threshold();
}
inline void DetectionOutputParameter::_internal_set_confidence_threshold(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.confidence_threshold_ = value;
}
inline void DetectionOutputParameter::set_confidence_threshold(float value) {
  _internal_set_confidence_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.confidence_threshold)
}

// optional bool normalized_bbox = 10 [default = true];
inline bool DetectionOutputParameter::_internal_has_normalized_bbox() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_normalized_bbox() const {
  return _internal_has_normalized_bbox();
}
inline void DetectionOutputParameter::clear_normalized_bbox() {
  _impl_.normalized_bbox_ = true;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool DetectionOutputParameter::_internal_normalized_bbox() const {
  return _impl_.normalized_bbox_;
}
inline bool DetectionOutputParameter::normalized_bbox() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.normalized_bbox)
  return _internal_normalized_bbox();
}
inline void DetectionOutputParameter::_internal_set_normalized_bbox(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.normalized_bbox_ = value;
}
inline void DetectionOutputParameter::set_normalized_bbox(bool value) {
  _internal_set_normalized_bbox(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.normalized_bbox)
}

// optional bool clip = 1000 [default = false];
inline bool DetectionOutputParameter::_internal_has_clip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool DetectionOutputParameter::has_clip() const {
  return _internal_has_clip();
}
inline void DetectionOutputParameter::clear_clip() {
  _impl_.clip_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool DetectionOutputParameter::_internal_clip() const {
  return _impl_.clip_;
}
inline bool DetectionOutputParameter::clip() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DetectionOutputParameter.clip)
  return _internal_clip();
}
inline void DetectionOutputParameter::_internal_set_clip(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.clip_ = value;
}
inline void DetectionOutputParameter::set_clip(bool value) {
  _internal_set_clip(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DetectionOutputParameter.clip)
}

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

// Datum

// optional int32 channels = 1;
inline bool Datum::_internal_has_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Datum::has_channels() const {
  return _internal_has_channels();
}
inline void Datum::clear_channels() {
  _impl_.channels_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Datum::_internal_channels() const {
  return _impl_.channels_;
}
inline int32_t Datum::channels() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.channels)
  return _internal_channels();
}
inline void Datum::_internal_set_channels(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.channels_ = value;
}
inline void Datum::set_channels(int32_t value) {
  _internal_set_channels(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.channels)
}

// optional int32 height = 2;
inline bool Datum::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Datum::has_height() const {
  return _internal_has_height();
}
inline void Datum::clear_height() {
  _impl_.height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Datum::_internal_height() const {
  return _impl_.height_;
}
inline int32_t Datum::height() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.height)
  return _internal_height();
}
inline void Datum::_internal_set_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.height_ = value;
}
inline void Datum::set_height(int32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.height)
}

// optional int32 width = 3;
inline bool Datum::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Datum::has_width() const {
  return _internal_has_width();
}
inline void Datum::clear_width() {
  _impl_.width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t Datum::_internal_width() const {
  return _impl_.width_;
}
inline int32_t Datum::width() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.width)
  return _internal_width();
}
inline void Datum::_internal_set_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.width_ = value;
}
inline void Datum::set_width(int32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.width)
}

// optional bytes data = 4;
inline bool Datum::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Datum::has_data() const {
  return _internal_has_data();
}
inline void Datum::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Datum::data() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Datum::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.data)
}
inline std::string* Datum::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.Datum.data)
  return _s;
}
inline const std::string& Datum::_internal_data() const {
  return _impl_.data_.Get();
}
inline void Datum::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* Datum::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* Datum::release_data() {
  // @@protoc_insertion_point(field_release:opencv_caffe.Datum.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Datum::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.Datum.data)
}

// optional int32 label = 5;
inline bool Datum::_internal_has_label() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Datum::has_label() const {
  return _internal_has_label();
}
inline void Datum::clear_label() {
  _impl_.label_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t Datum::_internal_label() const {
  return _impl_.label_;
}
inline int32_t Datum::label() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.label)
  return _internal_label();
}
inline void Datum::_internal_set_label(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.label_ = value;
}
inline void Datum::set_label(int32_t value) {
  _internal_set_label(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.label)
}

// repeated float float_data = 6;
inline int Datum::_internal_float_data_size() const {
  return _impl_.float_data_.size();
}
inline int Datum::float_data_size() const {
  return _internal_float_data_size();
}
inline void Datum::clear_float_data() {
  _impl_.float_data_.Clear();
}
inline float Datum::_internal_float_data(int index) const {
  return _impl_.float_data_.Get(index);
}
inline float Datum::float_data(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.float_data)
  return _internal_float_data(index);
}
inline void Datum::set_float_data(int index, float value) {
  _impl_.float_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.float_data)
}
inline void Datum::_internal_add_float_data(float value) {
  _impl_.float_data_.Add(value);
}
inline void Datum::add_float_data(float value) {
  _internal_add_float_data(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.Datum.float_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Datum::_internal_float_data() const {
  return _impl_.float_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Datum::float_data() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.Datum.float_data)
  return _internal_float_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Datum::_internal_mutable_float_data() {
  return &_impl_.float_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Datum::mutable_float_data() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.Datum.float_data)
  return _internal_mutable_float_data();
}

// optional bool encoded = 7 [default = false];
inline bool Datum::_internal_has_encoded() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Datum::has_encoded() const {
  return _internal_has_encoded();
}
inline void Datum::clear_encoded() {
  _impl_.encoded_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool Datum::_internal_encoded() const {
  return _impl_.encoded_;
}
inline bool Datum::encoded() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.Datum.encoded)
  return _internal_encoded();
}
inline void Datum::_internal_set_encoded(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.encoded_ = value;
}
inline void Datum::set_encoded(bool value) {
  _internal_set_encoded(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.Datum.encoded)
}

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

// FillerParameter

// optional string type = 1 [default = "constant"];
inline bool FillerParameter::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool FillerParameter::has_type() const {
  return _internal_has_type();
}
inline void FillerParameter::clear_type() {
  _impl_.type_.ClearToDefault(::opencv_caffe::FillerParameter::Impl_::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FillerParameter::type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.type)
  if (_impl_.type_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_type_.get();
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FillerParameter::set_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.type)
}
inline std::string* FillerParameter::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.FillerParameter.type)
  return _s;
}
inline const std::string& FillerParameter::_internal_type() const {
  return _impl_.type_.Get();
}
inline void FillerParameter::_internal_set_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_.Set(value, GetArenaForAllocation());
}
inline std::string* FillerParameter::_internal_mutable_type() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.type_.Mutable(::opencv_caffe::FillerParameter::Impl_::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
}
inline std::string* FillerParameter::release_type() {
  // @@protoc_insertion_point(field_release:opencv_caffe.FillerParameter.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.type_.Release();
  return p;
}
inline void FillerParameter::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.FillerParameter.type)
}

// optional float value = 2 [default = 0];
inline bool FillerParameter::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool FillerParameter::has_value() const {
  return _internal_has_value();
}
inline void FillerParameter::clear_value() {
  _impl_.value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float FillerParameter::_internal_value() const {
  return _impl_.value_;
}
inline float FillerParameter::value() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.value)
  return _internal_value();
}
inline void FillerParameter::_internal_set_value(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_ = value;
}
inline void FillerParameter::set_value(float value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.value)
}

// optional float min = 3 [default = 0];
inline bool FillerParameter::_internal_has_min() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool FillerParameter::has_min() const {
  return _internal_has_min();
}
inline void FillerParameter::clear_min() {
  _impl_.min_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float FillerParameter::_internal_min() const {
  return _impl_.min_;
}
inline float FillerParameter::min() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.min)
  return _internal_min();
}
inline void FillerParameter::_internal_set_min(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.min_ = value;
}
inline void FillerParameter::set_min(float value) {
  _internal_set_min(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.min)
}

// optional float max = 4 [default = 1];
inline bool FillerParameter::_internal_has_max() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool FillerParameter::has_max() const {
  return _internal_has_max();
}
inline void FillerParameter::clear_max() {
  _impl_.max_ = 1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float FillerParameter::_internal_max() const {
  return _impl_.max_;
}
inline float FillerParameter::max() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.max)
  return _internal_max();
}
inline void FillerParameter::_internal_set_max(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.max_ = value;
}
inline void FillerParameter::set_max(float value) {
  _internal_set_max(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.max)
}

// optional float mean = 5 [default = 0];
inline bool FillerParameter::_internal_has_mean() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool FillerParameter::has_mean() const {
  return _internal_has_mean();
}
inline void FillerParameter::clear_mean() {
  _impl_.mean_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float FillerParameter::_internal_mean() const {
  return _impl_.mean_;
}
inline float FillerParameter::mean() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.mean)
  return _internal_mean();
}
inline void FillerParameter::_internal_set_mean(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mean_ = value;
}
inline void FillerParameter::set_mean(float value) {
  _internal_set_mean(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.mean)
}

// optional float std = 6 [default = 1];
inline bool FillerParameter::_internal_has_std() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool FillerParameter::has_std() const {
  return _internal_has_std();
}
inline void FillerParameter::clear_std() {
  _impl_.std_ = 1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float FillerParameter::_internal_std() const {
  return _impl_.std_;
}
inline float FillerParameter::std() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.std)
  return _internal_std();
}
inline void FillerParameter::_internal_set_std(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.std_ = value;
}
inline void FillerParameter::set_std(float value) {
  _internal_set_std(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.std)
}

// optional int32 sparse = 7 [default = -1];
inline bool FillerParameter::_internal_has_sparse() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool FillerParameter::has_sparse() const {
  return _internal_has_sparse();
}
inline void FillerParameter::clear_sparse() {
  _impl_.sparse_ = -1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t FillerParameter::_internal_sparse() const {
  return _impl_.sparse_;
}
inline int32_t FillerParameter::sparse() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.sparse)
  return _internal_sparse();
}
inline void FillerParameter::_internal_set_sparse(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.sparse_ = value;
}
inline void FillerParameter::set_sparse(int32_t value) {
  _internal_set_sparse(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.sparse)
}

// optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
inline bool FillerParameter::_internal_has_variance_norm() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool FillerParameter::has_variance_norm() const {
  return _internal_has_variance_norm();
}
inline void FillerParameter::clear_variance_norm() {
  _impl_.variance_norm_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::opencv_caffe::FillerParameter_VarianceNorm FillerParameter::_internal_variance_norm() const {
  return static_cast< ::opencv_caffe::FillerParameter_VarianceNorm >(_impl_.variance_norm_);
}
inline ::opencv_caffe::FillerParameter_VarianceNorm FillerParameter::variance_norm() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FillerParameter.variance_norm)
  return _internal_variance_norm();
}
inline void FillerParameter::_internal_set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value) {
  assert(::opencv_caffe::FillerParameter_VarianceNorm_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.variance_norm_ = value;
}
inline void FillerParameter::set_variance_norm(::opencv_caffe::FillerParameter_VarianceNorm value) {
  _internal_set_variance_norm(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FillerParameter.variance_norm)
}

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

// NetParameter

// optional string name = 1;
inline bool NetParameter::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NetParameter::has_name() const {
  return _internal_has_name();
}
inline void NetParameter::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NetParameter::name() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NetParameter::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.name)
}
inline std::string* NetParameter::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.name)
  return _s;
}
inline const std::string& NetParameter::_internal_name() const {
  return _impl_.name_.Get();
}
inline void NetParameter::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* NetParameter::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* NetParameter::release_name() {
  // @@protoc_insertion_point(field_release:opencv_caffe.NetParameter.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NetParameter::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.NetParameter.name)
}

// repeated string input = 3;
inline int NetParameter::_internal_input_size() const {
  return _impl_.input_.size();
}
inline int NetParameter::input_size() const {
  return _internal_input_size();
}
inline void NetParameter::clear_input() {
  _impl_.input_.Clear();
}
inline std::string* NetParameter::add_input() {
  std::string* _s = _internal_add_input();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetParameter.input)
  return _s;
}
inline const std::string& NetParameter::_internal_input(int index) const {
  return _impl_.input_.Get(index);
}
inline const std::string& NetParameter::input(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input)
  return _internal_input(index);
}
inline std::string* NetParameter::mutable_input(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.input)
  return _impl_.input_.Mutable(index);
}
inline void NetParameter::set_input(int index, const std::string& value) {
  _impl_.input_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, std::string&& value) {
  _impl_.input_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.input_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.NetParameter.input)
}
inline void NetParameter::set_input(int index, const char* value, size_t size) {
  _impl_.input_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetParameter.input)
}
inline std::string* NetParameter::_internal_add_input() {
  return _impl_.input_.Add();
}
inline void NetParameter::add_input(const std::string& value) {
  _impl_.input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input)
}
inline void NetParameter::add_input(std::string&& value) {
  _impl_.input_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input)
}
inline void NetParameter::add_input(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.NetParameter.input)
}
inline void NetParameter::add_input(const char* value, size_t size) {
  _impl_.input_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetParameter.input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetParameter::input() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input)
  return _impl_.input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetParameter::mutable_input() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input)
  return &_impl_.input_;
}

// repeated .opencv_caffe.BlobShape input_shape = 8;
inline int NetParameter::_internal_input_shape_size() const {
  return _impl_.input_shape_.size();
}
inline int NetParameter::input_shape_size() const {
  return _internal_input_shape_size();
}
inline void NetParameter::clear_input_shape() {
  _impl_.input_shape_.Clear();
}
inline ::opencv_caffe::BlobShape* NetParameter::mutable_input_shape(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.input_shape)
  return _impl_.input_shape_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >*
NetParameter::mutable_input_shape() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input_shape)
  return &_impl_.input_shape_;
}
inline const ::opencv_caffe::BlobShape& NetParameter::_internal_input_shape(int index) const {
  return _impl_.input_shape_.Get(index);
}
inline const ::opencv_caffe::BlobShape& NetParameter::input_shape(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input_shape)
  return _internal_input_shape(index);
}
inline ::opencv_caffe::BlobShape* NetParameter::_internal_add_input_shape() {
  return _impl_.input_shape_.Add();
}
inline ::opencv_caffe::BlobShape* NetParameter::add_input_shape() {
  ::opencv_caffe::BlobShape* _add = _internal_add_input_shape();
  // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input_shape)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >&
NetParameter::input_shape() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input_shape)
  return _impl_.input_shape_;
}

// repeated int32 input_dim = 4;
inline int NetParameter::_internal_input_dim_size() const {
  return _impl_.input_dim_.size();
}
inline int NetParameter::input_dim_size() const {
  return _internal_input_dim_size();
}
inline void NetParameter::clear_input_dim() {
  _impl_.input_dim_.Clear();
}
inline int32_t NetParameter::_internal_input_dim(int index) const {
  return _impl_.input_dim_.Get(index);
}
inline int32_t NetParameter::input_dim(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.input_dim)
  return _internal_input_dim(index);
}
inline void NetParameter::set_input_dim(int index, int32_t value) {
  _impl_.input_dim_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.input_dim)
}
inline void NetParameter::_internal_add_input_dim(int32_t value) {
  _impl_.input_dim_.Add(value);
}
inline void NetParameter::add_input_dim(int32_t value) {
  _internal_add_input_dim(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.input_dim)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
NetParameter::_internal_input_dim() const {
  return _impl_.input_dim_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
NetParameter::input_dim() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.input_dim)
  return _internal_input_dim();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
NetParameter::_internal_mutable_input_dim() {
  return &_impl_.input_dim_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
NetParameter::mutable_input_dim() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.input_dim)
  return _internal_mutable_input_dim();
}

// optional bool force_backward = 5 [default = false];
inline bool NetParameter::_internal_has_force_backward() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NetParameter::has_force_backward() const {
  return _internal_has_force_backward();
}
inline void NetParameter::clear_force_backward() {
  _impl_.force_backward_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool NetParameter::_internal_force_backward() const {
  return _impl_.force_backward_;
}
inline bool NetParameter::force_backward() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.force_backward)
  return _internal_force_backward();
}
inline void NetParameter::_internal_set_force_backward(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.force_backward_ = value;
}
inline void NetParameter::set_force_backward(bool value) {
  _internal_set_force_backward(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.force_backward)
}

// optional .opencv_caffe.NetState state = 6;
inline bool NetParameter::_internal_has_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.state_ != nullptr);
  return value;
}
inline bool NetParameter::has_state() const {
  return _internal_has_state();
}
inline void NetParameter::clear_state() {
  if (_impl_.state_ != nullptr) _impl_.state_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::NetState& NetParameter::_internal_state() const {
  const ::opencv_caffe::NetState* p = _impl_.state_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::NetState&>(
      ::opencv_caffe::_NetState_default_instance_);
}
inline const ::opencv_caffe::NetState& NetParameter::state() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.state)
  return _internal_state();
}
inline void NetParameter::unsafe_arena_set_allocated_state(
    ::opencv_caffe::NetState* state) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.state_);
  }
  _impl_.state_ = state;
  if (state) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.NetParameter.state)
}
inline ::opencv_caffe::NetState* NetParameter::release_state() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::NetState* temp = _impl_.state_;
  _impl_.state_ = 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 ::opencv_caffe::NetState* NetParameter::unsafe_arena_release_state() {
  // @@protoc_insertion_point(field_release:opencv_caffe.NetParameter.state)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::NetState* temp = _impl_.state_;
  _impl_.state_ = nullptr;
  return temp;
}
inline ::opencv_caffe::NetState* NetParameter::_internal_mutable_state() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.state_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::NetState>(GetArenaForAllocation());
    _impl_.state_ = p;
  }
  return _impl_.state_;
}
inline ::opencv_caffe::NetState* NetParameter::mutable_state() {
  ::opencv_caffe::NetState* _msg = _internal_mutable_state();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.state)
  return _msg;
}
inline void NetParameter::set_allocated_state(::opencv_caffe::NetState* state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.state_;
  }
  if (state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(state);
    if (message_arena != submessage_arena) {
      state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, state, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.state_ = state;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.NetParameter.state)
}

// optional bool debug_info = 7 [default = false];
inline bool NetParameter::_internal_has_debug_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NetParameter::has_debug_info() const {
  return _internal_has_debug_info();
}
inline void NetParameter::clear_debug_info() {
  _impl_.debug_info_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool NetParameter::_internal_debug_info() const {
  return _impl_.debug_info_;
}
inline bool NetParameter::debug_info() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.debug_info)
  return _internal_debug_info();
}
inline void NetParameter::_internal_set_debug_info(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.debug_info_ = value;
}
inline void NetParameter::set_debug_info(bool value) {
  _internal_set_debug_info(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetParameter.debug_info)
}

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

// repeated .opencv_caffe.V1LayerParameter layers = 2;
inline int NetParameter::_internal_layers_size() const {
  return _impl_.layers_.size();
}
inline int NetParameter::layers_size() const {
  return _internal_layers_size();
}
inline void NetParameter::clear_layers() {
  _impl_.layers_.Clear();
}
inline ::opencv_caffe::V1LayerParameter* NetParameter::mutable_layers(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetParameter.layers)
  return _impl_.layers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >*
NetParameter::mutable_layers() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetParameter.layers)
  return &_impl_.layers_;
}
inline const ::opencv_caffe::V1LayerParameter& NetParameter::_internal_layers(int index) const {
  return _impl_.layers_.Get(index);
}
inline const ::opencv_caffe::V1LayerParameter& NetParameter::layers(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetParameter.layers)
  return _internal_layers(index);
}
inline ::opencv_caffe::V1LayerParameter* NetParameter::_internal_add_layers() {
  return _impl_.layers_.Add();
}
inline ::opencv_caffe::V1LayerParameter* NetParameter::add_layers() {
  ::opencv_caffe::V1LayerParameter* _add = _internal_add_layers();
  // @@protoc_insertion_point(field_add:opencv_caffe.NetParameter.layers)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::V1LayerParameter >&
NetParameter::layers() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetParameter.layers)
  return _impl_.layers_;
}

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

// SolverParameter

// optional string net = 24;
inline bool SolverParameter::_internal_has_net() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SolverParameter::has_net() const {
  return _internal_has_net();
}
inline void SolverParameter::clear_net() {
  _impl_.net_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SolverParameter::net() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.net)
  return _internal_net();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_net(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.net_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.net)
}
inline std::string* SolverParameter::mutable_net() {
  std::string* _s = _internal_mutable_net();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.net)
  return _s;
}
inline const std::string& SolverParameter::_internal_net() const {
  return _impl_.net_.Get();
}
inline void SolverParameter::_internal_set_net(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.net_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_net() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.net_.Mutable(GetArenaForAllocation());
}
inline std::string* SolverParameter::release_net() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.net)
  if (!_internal_has_net()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.net_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.net_.IsDefault()) {
    _impl_.net_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SolverParameter::set_allocated_net(std::string* net) {
  if (net != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.net_.SetAllocated(net, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.net_.IsDefault()) {
    _impl_.net_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.net)
}

// optional .opencv_caffe.NetParameter net_param = 25;
inline bool SolverParameter::_internal_has_net_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.net_param_ != nullptr);
  return value;
}
inline bool SolverParameter::has_net_param() const {
  return _internal_has_net_param();
}
inline void SolverParameter::clear_net_param() {
  if (_impl_.net_param_ != nullptr) _impl_.net_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::opencv_caffe::NetParameter& SolverParameter::_internal_net_param() const {
  const ::opencv_caffe::NetParameter* p = _impl_.net_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::NetParameter&>(
      ::opencv_caffe::_NetParameter_default_instance_);
}
inline const ::opencv_caffe::NetParameter& SolverParameter::net_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.net_param)
  return _internal_net_param();
}
inline void SolverParameter::unsafe_arena_set_allocated_net_param(
    ::opencv_caffe::NetParameter* net_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.net_param_);
  }
  _impl_.net_param_ = net_param;
  if (net_param) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.SolverParameter.net_param)
}
inline ::opencv_caffe::NetParameter* SolverParameter::release_net_param() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::NetParameter* temp = _impl_.net_param_;
  _impl_.net_param_ = 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 ::opencv_caffe::NetParameter* SolverParameter::unsafe_arena_release_net_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.net_param)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::NetParameter* temp = _impl_.net_param_;
  _impl_.net_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::NetParameter* SolverParameter::_internal_mutable_net_param() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.net_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::NetParameter>(GetArenaForAllocation());
    _impl_.net_param_ = p;
  }
  return _impl_.net_param_;
}
inline ::opencv_caffe::NetParameter* SolverParameter::mutable_net_param() {
  ::opencv_caffe::NetParameter* _msg = _internal_mutable_net_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.net_param)
  return _msg;
}
inline void SolverParameter::set_allocated_net_param(::opencv_caffe::NetParameter* net_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.net_param_;
  }
  if (net_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(net_param);
    if (message_arena != submessage_arena) {
      net_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, net_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.net_param_ = net_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.net_param)
}

// optional string train_net = 1;
inline bool SolverParameter::_internal_has_train_net() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SolverParameter::has_train_net() const {
  return _internal_has_train_net();
}
inline void SolverParameter::clear_train_net() {
  _impl_.train_net_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SolverParameter::train_net() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_net)
  return _internal_train_net();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_train_net(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.train_net_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.train_net)
}
inline std::string* SolverParameter::mutable_train_net() {
  std::string* _s = _internal_mutable_train_net();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_net)
  return _s;
}
inline const std::string& SolverParameter::_internal_train_net() const {
  return _impl_.train_net_.Get();
}
inline void SolverParameter::_internal_set_train_net(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.train_net_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_train_net() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.train_net_.Mutable(GetArenaForAllocation());
}
inline std::string* SolverParameter::release_train_net() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_net)
  if (!_internal_has_train_net()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.train_net_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.train_net_.IsDefault()) {
    _impl_.train_net_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SolverParameter::set_allocated_train_net(std::string* train_net) {
  if (train_net != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.train_net_.SetAllocated(train_net, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.train_net_.IsDefault()) {
    _impl_.train_net_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_net)
}

// repeated string test_net = 2;
inline int SolverParameter::_internal_test_net_size() const {
  return _impl_.test_net_.size();
}
inline int SolverParameter::test_net_size() const {
  return _internal_test_net_size();
}
inline void SolverParameter::clear_test_net() {
  _impl_.test_net_.Clear();
}
inline std::string* SolverParameter::add_test_net() {
  std::string* _s = _internal_add_test_net();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.SolverParameter.test_net)
  return _s;
}
inline const std::string& SolverParameter::_internal_test_net(int index) const {
  return _impl_.test_net_.Get(index);
}
inline const std::string& SolverParameter::test_net(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_net)
  return _internal_test_net(index);
}
inline std::string* SolverParameter::mutable_test_net(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.test_net)
  return _impl_.test_net_.Mutable(index);
}
inline void SolverParameter::set_test_net(int index, const std::string& value) {
  _impl_.test_net_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, std::string&& value) {
  _impl_.test_net_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.test_net_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::set_test_net(int index, const char* value, size_t size) {
  _impl_.test_net_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.SolverParameter.test_net)
}
inline std::string* SolverParameter::_internal_add_test_net() {
  return _impl_.test_net_.Add();
}
inline void SolverParameter::add_test_net(const std::string& value) {
  _impl_.test_net_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(std::string&& value) {
  _impl_.test_net_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.test_net_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.SolverParameter.test_net)
}
inline void SolverParameter::add_test_net(const char* value, size_t size) {
  _impl_.test_net_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.SolverParameter.test_net)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SolverParameter::test_net() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_net)
  return _impl_.test_net_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SolverParameter::mutable_test_net() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_net)
  return &_impl_.test_net_;
}

// optional .opencv_caffe.NetParameter train_net_param = 21;
inline bool SolverParameter::_internal_has_train_net_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.train_net_param_ != nullptr);
  return value;
}
inline bool SolverParameter::has_train_net_param() const {
  return _internal_has_train_net_param();
}
inline void SolverParameter::clear_train_net_param() {
  if (_impl_.train_net_param_ != nullptr) _impl_.train_net_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::opencv_caffe::NetParameter& SolverParameter::_internal_train_net_param() const {
  const ::opencv_caffe::NetParameter* p = _impl_.train_net_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::NetParameter&>(
      ::opencv_caffe::_NetParameter_default_instance_);
}
inline const ::opencv_caffe::NetParameter& SolverParameter::train_net_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_net_param)
  return _internal_train_net_param();
}
inline void SolverParameter::unsafe_arena_set_allocated_train_net_param(
    ::opencv_caffe::NetParameter* train_net_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.train_net_param_);
  }
  _impl_.train_net_param_ = train_net_param;
  if (train_net_param) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.SolverParameter.train_net_param)
}
inline ::opencv_caffe::NetParameter* SolverParameter::release_train_net_param() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::NetParameter* temp = _impl_.train_net_param_;
  _impl_.train_net_param_ = 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 ::opencv_caffe::NetParameter* SolverParameter::unsafe_arena_release_train_net_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_net_param)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::NetParameter* temp = _impl_.train_net_param_;
  _impl_.train_net_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::NetParameter* SolverParameter::_internal_mutable_train_net_param() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.train_net_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::NetParameter>(GetArenaForAllocation());
    _impl_.train_net_param_ = p;
  }
  return _impl_.train_net_param_;
}
inline ::opencv_caffe::NetParameter* SolverParameter::mutable_train_net_param() {
  ::opencv_caffe::NetParameter* _msg = _internal_mutable_train_net_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_net_param)
  return _msg;
}
inline void SolverParameter::set_allocated_train_net_param(::opencv_caffe::NetParameter* train_net_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.train_net_param_;
  }
  if (train_net_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(train_net_param);
    if (message_arena != submessage_arena) {
      train_net_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, train_net_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.train_net_param_ = train_net_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_net_param)
}

// repeated .opencv_caffe.NetParameter test_net_param = 22;
inline int SolverParameter::_internal_test_net_param_size() const {
  return _impl_.test_net_param_.size();
}
inline int SolverParameter::test_net_param_size() const {
  return _internal_test_net_param_size();
}
inline void SolverParameter::clear_test_net_param() {
  _impl_.test_net_param_.Clear();
}
inline ::opencv_caffe::NetParameter* SolverParameter::mutable_test_net_param(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.test_net_param)
  return _impl_.test_net_param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter >*
SolverParameter::mutable_test_net_param() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_net_param)
  return &_impl_.test_net_param_;
}
inline const ::opencv_caffe::NetParameter& SolverParameter::_internal_test_net_param(int index) const {
  return _impl_.test_net_param_.Get(index);
}
inline const ::opencv_caffe::NetParameter& SolverParameter::test_net_param(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_net_param)
  return _internal_test_net_param(index);
}
inline ::opencv_caffe::NetParameter* SolverParameter::_internal_add_test_net_param() {
  return _impl_.test_net_param_.Add();
}
inline ::opencv_caffe::NetParameter* SolverParameter::add_test_net_param() {
  ::opencv_caffe::NetParameter* _add = _internal_add_test_net_param();
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_net_param)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetParameter >&
SolverParameter::test_net_param() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_net_param)
  return _impl_.test_net_param_;
}

// optional .opencv_caffe.NetState train_state = 26;
inline bool SolverParameter::_internal_has_train_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.train_state_ != nullptr);
  return value;
}
inline bool SolverParameter::has_train_state() const {
  return _internal_has_train_state();
}
inline void SolverParameter::clear_train_state() {
  if (_impl_.train_state_ != nullptr) _impl_.train_state_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::opencv_caffe::NetState& SolverParameter::_internal_train_state() const {
  const ::opencv_caffe::NetState* p = _impl_.train_state_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::NetState&>(
      ::opencv_caffe::_NetState_default_instance_);
}
inline const ::opencv_caffe::NetState& SolverParameter::train_state() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.train_state)
  return _internal_train_state();
}
inline void SolverParameter::unsafe_arena_set_allocated_train_state(
    ::opencv_caffe::NetState* train_state) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.train_state_);
  }
  _impl_.train_state_ = train_state;
  if (train_state) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.SolverParameter.train_state)
}
inline ::opencv_caffe::NetState* SolverParameter::release_train_state() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::opencv_caffe::NetState* temp = _impl_.train_state_;
  _impl_.train_state_ = 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 ::opencv_caffe::NetState* SolverParameter::unsafe_arena_release_train_state() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.train_state)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::opencv_caffe::NetState* temp = _impl_.train_state_;
  _impl_.train_state_ = nullptr;
  return temp;
}
inline ::opencv_caffe::NetState* SolverParameter::_internal_mutable_train_state() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.train_state_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::NetState>(GetArenaForAllocation());
    _impl_.train_state_ = p;
  }
  return _impl_.train_state_;
}
inline ::opencv_caffe::NetState* SolverParameter::mutable_train_state() {
  ::opencv_caffe::NetState* _msg = _internal_mutable_train_state();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.train_state)
  return _msg;
}
inline void SolverParameter::set_allocated_train_state(::opencv_caffe::NetState* train_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.train_state_;
  }
  if (train_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(train_state);
    if (message_arena != submessage_arena) {
      train_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, train_state, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.train_state_ = train_state;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.train_state)
}

// repeated .opencv_caffe.NetState test_state = 27;
inline int SolverParameter::_internal_test_state_size() const {
  return _impl_.test_state_.size();
}
inline int SolverParameter::test_state_size() const {
  return _internal_test_state_size();
}
inline void SolverParameter::clear_test_state() {
  _impl_.test_state_.Clear();
}
inline ::opencv_caffe::NetState* SolverParameter::mutable_test_state(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.test_state)
  return _impl_.test_state_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >*
SolverParameter::mutable_test_state() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_state)
  return &_impl_.test_state_;
}
inline const ::opencv_caffe::NetState& SolverParameter::_internal_test_state(int index) const {
  return _impl_.test_state_.Get(index);
}
inline const ::opencv_caffe::NetState& SolverParameter::test_state(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_state)
  return _internal_test_state(index);
}
inline ::opencv_caffe::NetState* SolverParameter::_internal_add_test_state() {
  return _impl_.test_state_.Add();
}
inline ::opencv_caffe::NetState* SolverParameter::add_test_state() {
  ::opencv_caffe::NetState* _add = _internal_add_test_state();
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_state)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetState >&
SolverParameter::test_state() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_state)
  return _impl_.test_state_;
}

// repeated int32 test_iter = 3;
inline int SolverParameter::_internal_test_iter_size() const {
  return _impl_.test_iter_.size();
}
inline int SolverParameter::test_iter_size() const {
  return _internal_test_iter_size();
}
inline void SolverParameter::clear_test_iter() {
  _impl_.test_iter_.Clear();
}
inline int32_t SolverParameter::_internal_test_iter(int index) const {
  return _impl_.test_iter_.Get(index);
}
inline int32_t SolverParameter::test_iter(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_iter)
  return _internal_test_iter(index);
}
inline void SolverParameter::set_test_iter(int index, int32_t value) {
  _impl_.test_iter_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_iter)
}
inline void SolverParameter::_internal_add_test_iter(int32_t value) {
  _impl_.test_iter_.Add(value);
}
inline void SolverParameter::add_test_iter(int32_t value) {
  _internal_add_test_iter(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.test_iter)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::_internal_test_iter() const {
  return _impl_.test_iter_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::test_iter() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.test_iter)
  return _internal_test_iter();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::_internal_mutable_test_iter() {
  return &_impl_.test_iter_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::mutable_test_iter() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.test_iter)
  return _internal_mutable_test_iter();
}

// optional int32 test_interval = 4 [default = 0];
inline bool SolverParameter::_internal_has_test_interval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SolverParameter::has_test_interval() const {
  return _internal_has_test_interval();
}
inline void SolverParameter::clear_test_interval() {
  _impl_.test_interval_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t SolverParameter::_internal_test_interval() const {
  return _impl_.test_interval_;
}
inline int32_t SolverParameter::test_interval() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_interval)
  return _internal_test_interval();
}
inline void SolverParameter::_internal_set_test_interval(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.test_interval_ = value;
}
inline void SolverParameter::set_test_interval(int32_t value) {
  _internal_set_test_interval(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_interval)
}

// optional bool test_compute_loss = 19 [default = false];
inline bool SolverParameter::_internal_has_test_compute_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool SolverParameter::has_test_compute_loss() const {
  return _internal_has_test_compute_loss();
}
inline void SolverParameter::clear_test_compute_loss() {
  _impl_.test_compute_loss_ = false;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline bool SolverParameter::_internal_test_compute_loss() const {
  return _impl_.test_compute_loss_;
}
inline bool SolverParameter::test_compute_loss() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_compute_loss)
  return _internal_test_compute_loss();
}
inline void SolverParameter::_internal_set_test_compute_loss(bool value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.test_compute_loss_ = value;
}
inline void SolverParameter::set_test_compute_loss(bool value) {
  _internal_set_test_compute_loss(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_compute_loss)
}

// optional bool test_initialization = 32 [default = true];
inline bool SolverParameter::_internal_has_test_initialization() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool SolverParameter::has_test_initialization() const {
  return _internal_has_test_initialization();
}
inline void SolverParameter::clear_test_initialization() {
  _impl_.test_initialization_ = true;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline bool SolverParameter::_internal_test_initialization() const {
  return _impl_.test_initialization_;
}
inline bool SolverParameter::test_initialization() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.test_initialization)
  return _internal_test_initialization();
}
inline void SolverParameter::_internal_set_test_initialization(bool value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.test_initialization_ = value;
}
inline void SolverParameter::set_test_initialization(bool value) {
  _internal_set_test_initialization(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.test_initialization)
}

// optional float base_lr = 5;
inline bool SolverParameter::_internal_has_base_lr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool SolverParameter::has_base_lr() const {
  return _internal_has_base_lr();
}
inline void SolverParameter::clear_base_lr() {
  _impl_.base_lr_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float SolverParameter::_internal_base_lr() const {
  return _impl_.base_lr_;
}
inline float SolverParameter::base_lr() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.base_lr)
  return _internal_base_lr();
}
inline void SolverParameter::_internal_set_base_lr(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.base_lr_ = value;
}
inline void SolverParameter::set_base_lr(float value) {
  _internal_set_base_lr(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.base_lr)
}

// optional int32 display = 6;
inline bool SolverParameter::_internal_has_display() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool SolverParameter::has_display() const {
  return _internal_has_display();
}
inline void SolverParameter::clear_display() {
  _impl_.display_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t SolverParameter::_internal_display() const {
  return _impl_.display_;
}
inline int32_t SolverParameter::display() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.display)
  return _internal_display();
}
inline void SolverParameter::_internal_set_display(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.display_ = value;
}
inline void SolverParameter::set_display(int32_t value) {
  _internal_set_display(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.display)
}

// optional int32 average_loss = 33 [default = 1];
inline bool SolverParameter::_internal_has_average_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool SolverParameter::has_average_loss() const {
  return _internal_has_average_loss();
}
inline void SolverParameter::clear_average_loss() {
  _impl_.average_loss_ = 1;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline int32_t SolverParameter::_internal_average_loss() const {
  return _impl_.average_loss_;
}
inline int32_t SolverParameter::average_loss() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.average_loss)
  return _internal_average_loss();
}
inline void SolverParameter::_internal_set_average_loss(int32_t value) {
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.average_loss_ = value;
}
inline void SolverParameter::set_average_loss(int32_t value) {
  _internal_set_average_loss(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.average_loss)
}

// optional int32 max_iter = 7;
inline bool SolverParameter::_internal_has_max_iter() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool SolverParameter::has_max_iter() const {
  return _internal_has_max_iter();
}
inline void SolverParameter::clear_max_iter() {
  _impl_.max_iter_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t SolverParameter::_internal_max_iter() const {
  return _impl_.max_iter_;
}
inline int32_t SolverParameter::max_iter() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.max_iter)
  return _internal_max_iter();
}
inline void SolverParameter::_internal_set_max_iter(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.max_iter_ = value;
}
inline void SolverParameter::set_max_iter(int32_t value) {
  _internal_set_max_iter(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.max_iter)
}

// optional int32 iter_size = 36 [default = 1];
inline bool SolverParameter::_internal_has_iter_size() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool SolverParameter::has_iter_size() const {
  return _internal_has_iter_size();
}
inline void SolverParameter::clear_iter_size() {
  _impl_.iter_size_ = 1;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline int32_t SolverParameter::_internal_iter_size() const {
  return _impl_.iter_size_;
}
inline int32_t SolverParameter::iter_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.iter_size)
  return _internal_iter_size();
}
inline void SolverParameter::_internal_set_iter_size(int32_t value) {
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.iter_size_ = value;
}
inline void SolverParameter::set_iter_size(int32_t value) {
  _internal_set_iter_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.iter_size)
}

// optional string lr_policy = 8;
inline bool SolverParameter::_internal_has_lr_policy() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SolverParameter::has_lr_policy() const {
  return _internal_has_lr_policy();
}
inline void SolverParameter::clear_lr_policy() {
  _impl_.lr_policy_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SolverParameter::lr_policy() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.lr_policy)
  return _internal_lr_policy();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_lr_policy(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.lr_policy_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.lr_policy)
}
inline std::string* SolverParameter::mutable_lr_policy() {
  std::string* _s = _internal_mutable_lr_policy();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.lr_policy)
  return _s;
}
inline const std::string& SolverParameter::_internal_lr_policy() const {
  return _impl_.lr_policy_.Get();
}
inline void SolverParameter::_internal_set_lr_policy(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.lr_policy_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_lr_policy() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.lr_policy_.Mutable(GetArenaForAllocation());
}
inline std::string* SolverParameter::release_lr_policy() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.lr_policy)
  if (!_internal_has_lr_policy()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.lr_policy_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lr_policy_.IsDefault()) {
    _impl_.lr_policy_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SolverParameter::set_allocated_lr_policy(std::string* lr_policy) {
  if (lr_policy != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.lr_policy_.SetAllocated(lr_policy, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lr_policy_.IsDefault()) {
    _impl_.lr_policy_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.lr_policy)
}

// optional float gamma = 9;
inline bool SolverParameter::_internal_has_gamma() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool SolverParameter::has_gamma() const {
  return _internal_has_gamma();
}
inline void SolverParameter::clear_gamma() {
  _impl_.gamma_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline float SolverParameter::_internal_gamma() const {
  return _impl_.gamma_;
}
inline float SolverParameter::gamma() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.gamma)
  return _internal_gamma();
}
inline void SolverParameter::_internal_set_gamma(float value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.gamma_ = value;
}
inline void SolverParameter::set_gamma(float value) {
  _internal_set_gamma(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.gamma)
}

// optional float power = 10;
inline bool SolverParameter::_internal_has_power() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool SolverParameter::has_power() const {
  return _internal_has_power();
}
inline void SolverParameter::clear_power() {
  _impl_.power_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline float SolverParameter::_internal_power() const {
  return _impl_.power_;
}
inline float SolverParameter::power() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.power)
  return _internal_power();
}
inline void SolverParameter::_internal_set_power(float value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.power_ = value;
}
inline void SolverParameter::set_power(float value) {
  _internal_set_power(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.power)
}

// optional float momentum = 11;
inline bool SolverParameter::_internal_has_momentum() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool SolverParameter::has_momentum() const {
  return _internal_has_momentum();
}
inline void SolverParameter::clear_momentum() {
  _impl_.momentum_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline float SolverParameter::_internal_momentum() const {
  return _impl_.momentum_;
}
inline float SolverParameter::momentum() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.momentum)
  return _internal_momentum();
}
inline void SolverParameter::_internal_set_momentum(float value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.momentum_ = value;
}
inline void SolverParameter::set_momentum(float value) {
  _internal_set_momentum(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.momentum)
}

// optional float weight_decay = 12;
inline bool SolverParameter::_internal_has_weight_decay() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool SolverParameter::has_weight_decay() const {
  return _internal_has_weight_decay();
}
inline void SolverParameter::clear_weight_decay() {
  _impl_.weight_decay_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline float SolverParameter::_internal_weight_decay() const {
  return _impl_.weight_decay_;
}
inline float SolverParameter::weight_decay() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.weight_decay)
  return _internal_weight_decay();
}
inline void SolverParameter::_internal_set_weight_decay(float value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.weight_decay_ = value;
}
inline void SolverParameter::set_weight_decay(float value) {
  _internal_set_weight_decay(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.weight_decay)
}

// optional string regularization_type = 29 [default = "L2"];
inline bool SolverParameter::_internal_has_regularization_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SolverParameter::has_regularization_type() const {
  return _internal_has_regularization_type();
}
inline void SolverParameter::clear_regularization_type() {
  _impl_.regularization_type_.ClearToDefault(::opencv_caffe::SolverParameter::Impl_::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SolverParameter::regularization_type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.regularization_type)
  if (_impl_.regularization_type_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_regularization_type_.get();
  return _internal_regularization_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_regularization_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.regularization_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.regularization_type)
}
inline std::string* SolverParameter::mutable_regularization_type() {
  std::string* _s = _internal_mutable_regularization_type();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.regularization_type)
  return _s;
}
inline const std::string& SolverParameter::_internal_regularization_type() const {
  return _impl_.regularization_type_.Get();
}
inline void SolverParameter::_internal_set_regularization_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.regularization_type_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_regularization_type() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.regularization_type_.Mutable(::opencv_caffe::SolverParameter::Impl_::_i_give_permission_to_break_this_code_default_regularization_type_, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_regularization_type() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.regularization_type)
  if (!_internal_has_regularization_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.regularization_type_.Release();
  return p;
}
inline void SolverParameter::set_allocated_regularization_type(std::string* regularization_type) {
  if (regularization_type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.regularization_type_.SetAllocated(regularization_type, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.regularization_type)
}

// optional int32 stepsize = 13;
inline bool SolverParameter::_internal_has_stepsize() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool SolverParameter::has_stepsize() const {
  return _internal_has_stepsize();
}
inline void SolverParameter::clear_stepsize() {
  _impl_.stepsize_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int32_t SolverParameter::_internal_stepsize() const {
  return _impl_.stepsize_;
}
inline int32_t SolverParameter::stepsize() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.stepsize)
  return _internal_stepsize();
}
inline void SolverParameter::_internal_set_stepsize(int32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.stepsize_ = value;
}
inline void SolverParameter::set_stepsize(int32_t value) {
  _internal_set_stepsize(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.stepsize)
}

// repeated int32 stepvalue = 34;
inline int SolverParameter::_internal_stepvalue_size() const {
  return _impl_.stepvalue_.size();
}
inline int SolverParameter::stepvalue_size() const {
  return _internal_stepvalue_size();
}
inline void SolverParameter::clear_stepvalue() {
  _impl_.stepvalue_.Clear();
}
inline int32_t SolverParameter::_internal_stepvalue(int index) const {
  return _impl_.stepvalue_.Get(index);
}
inline int32_t SolverParameter::stepvalue(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.stepvalue)
  return _internal_stepvalue(index);
}
inline void SolverParameter::set_stepvalue(int index, int32_t value) {
  _impl_.stepvalue_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.stepvalue)
}
inline void SolverParameter::_internal_add_stepvalue(int32_t value) {
  _impl_.stepvalue_.Add(value);
}
inline void SolverParameter::add_stepvalue(int32_t value) {
  _internal_add_stepvalue(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverParameter.stepvalue)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::_internal_stepvalue() const {
  return _impl_.stepvalue_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SolverParameter::stepvalue() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SolverParameter.stepvalue)
  return _internal_stepvalue();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::_internal_mutable_stepvalue() {
  return &_impl_.stepvalue_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SolverParameter::mutable_stepvalue() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverParameter.stepvalue)
  return _internal_mutable_stepvalue();
}

// optional float clip_gradients = 35 [default = -1];
inline bool SolverParameter::_internal_has_clip_gradients() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool SolverParameter::has_clip_gradients() const {
  return _internal_has_clip_gradients();
}
inline void SolverParameter::clear_clip_gradients() {
  _impl_.clip_gradients_ = -1;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline float SolverParameter::_internal_clip_gradients() const {
  return _impl_.clip_gradients_;
}
inline float SolverParameter::clip_gradients() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.clip_gradients)
  return _internal_clip_gradients();
}
inline void SolverParameter::_internal_set_clip_gradients(float value) {
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.clip_gradients_ = value;
}
inline void SolverParameter::set_clip_gradients(float value) {
  _internal_set_clip_gradients(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.clip_gradients)
}

// optional int32 snapshot = 14 [default = 0];
inline bool SolverParameter::_internal_has_snapshot() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool SolverParameter::has_snapshot() const {
  return _internal_has_snapshot();
}
inline void SolverParameter::clear_snapshot() {
  _impl_.snapshot_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline int32_t SolverParameter::_internal_snapshot() const {
  return _impl_.snapshot_;
}
inline int32_t SolverParameter::snapshot() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot)
  return _internal_snapshot();
}
inline void SolverParameter::_internal_set_snapshot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.snapshot_ = value;
}
inline void SolverParameter::set_snapshot(int32_t value) {
  _internal_set_snapshot(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot)
}

// optional string snapshot_prefix = 15;
inline bool SolverParameter::_internal_has_snapshot_prefix() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SolverParameter::has_snapshot_prefix() const {
  return _internal_has_snapshot_prefix();
}
inline void SolverParameter::clear_snapshot_prefix() {
  _impl_.snapshot_prefix_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SolverParameter::snapshot_prefix() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_prefix)
  return _internal_snapshot_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_snapshot_prefix(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.snapshot_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_prefix)
}
inline std::string* SolverParameter::mutable_snapshot_prefix() {
  std::string* _s = _internal_mutable_snapshot_prefix();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.snapshot_prefix)
  return _s;
}
inline const std::string& SolverParameter::_internal_snapshot_prefix() const {
  return _impl_.snapshot_prefix_.Get();
}
inline void SolverParameter::_internal_set_snapshot_prefix(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.snapshot_prefix_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_snapshot_prefix() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.snapshot_prefix_.Mutable(GetArenaForAllocation());
}
inline std::string* SolverParameter::release_snapshot_prefix() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.snapshot_prefix)
  if (!_internal_has_snapshot_prefix()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.snapshot_prefix_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshot_prefix_.IsDefault()) {
    _impl_.snapshot_prefix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SolverParameter::set_allocated_snapshot_prefix(std::string* snapshot_prefix) {
  if (snapshot_prefix != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.snapshot_prefix_.SetAllocated(snapshot_prefix, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshot_prefix_.IsDefault()) {
    _impl_.snapshot_prefix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.snapshot_prefix)
}

// optional bool snapshot_diff = 16 [default = false];
inline bool SolverParameter::_internal_has_snapshot_diff() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool SolverParameter::has_snapshot_diff() const {
  return _internal_has_snapshot_diff();
}
inline void SolverParameter::clear_snapshot_diff() {
  _impl_.snapshot_diff_ = false;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline bool SolverParameter::_internal_snapshot_diff() const {
  return _impl_.snapshot_diff_;
}
inline bool SolverParameter::snapshot_diff() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_diff)
  return _internal_snapshot_diff();
}
inline void SolverParameter::_internal_set_snapshot_diff(bool value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.snapshot_diff_ = value;
}
inline void SolverParameter::set_snapshot_diff(bool value) {
  _internal_set_snapshot_diff(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_diff)
}

// optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
inline bool SolverParameter::_internal_has_snapshot_format() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool SolverParameter::has_snapshot_format() const {
  return _internal_has_snapshot_format();
}
inline void SolverParameter::clear_snapshot_format() {
  _impl_.snapshot_format_ = 1;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline ::opencv_caffe::SolverParameter_SnapshotFormat SolverParameter::_internal_snapshot_format() const {
  return static_cast< ::opencv_caffe::SolverParameter_SnapshotFormat >(_impl_.snapshot_format_);
}
inline ::opencv_caffe::SolverParameter_SnapshotFormat SolverParameter::snapshot_format() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_format)
  return _internal_snapshot_format();
}
inline void SolverParameter::_internal_set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value) {
  assert(::opencv_caffe::SolverParameter_SnapshotFormat_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.snapshot_format_ = value;
}
inline void SolverParameter::set_snapshot_format(::opencv_caffe::SolverParameter_SnapshotFormat value) {
  _internal_set_snapshot_format(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_format)
}

// optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
inline bool SolverParameter::_internal_has_solver_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool SolverParameter::has_solver_mode() const {
  return _internal_has_solver_mode();
}
inline void SolverParameter::clear_solver_mode() {
  _impl_.solver_mode_ = 1;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline ::opencv_caffe::SolverParameter_SolverMode SolverParameter::_internal_solver_mode() const {
  return static_cast< ::opencv_caffe::SolverParameter_SolverMode >(_impl_.solver_mode_);
}
inline ::opencv_caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.solver_mode)
  return _internal_solver_mode();
}
inline void SolverParameter::_internal_set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value) {
  assert(::opencv_caffe::SolverParameter_SolverMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.solver_mode_ = value;
}
inline void SolverParameter::set_solver_mode(::opencv_caffe::SolverParameter_SolverMode value) {
  _internal_set_solver_mode(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.solver_mode)
}

// optional int32 device_id = 18 [default = 0];
inline bool SolverParameter::_internal_has_device_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool SolverParameter::has_device_id() const {
  return _internal_has_device_id();
}
inline void SolverParameter::clear_device_id() {
  _impl_.device_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int32_t SolverParameter::_internal_device_id() const {
  return _impl_.device_id_;
}
inline int32_t SolverParameter::device_id() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.device_id)
  return _internal_device_id();
}
inline void SolverParameter::_internal_set_device_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.device_id_ = value;
}
inline void SolverParameter::set_device_id(int32_t value) {
  _internal_set_device_id(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.device_id)
}

// optional int64 random_seed = 20 [default = -1];
inline bool SolverParameter::_internal_has_random_seed() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool SolverParameter::has_random_seed() const {
  return _internal_has_random_seed();
}
inline void SolverParameter::clear_random_seed() {
  _impl_.random_seed_ = int64_t{-1};
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline int64_t SolverParameter::_internal_random_seed() const {
  return _impl_.random_seed_;
}
inline int64_t SolverParameter::random_seed() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.random_seed)
  return _internal_random_seed();
}
inline void SolverParameter::_internal_set_random_seed(int64_t value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.random_seed_ = value;
}
inline void SolverParameter::set_random_seed(int64_t value) {
  _internal_set_random_seed(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.random_seed)
}

// optional string type = 40 [default = "SGD"];
inline bool SolverParameter::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SolverParameter::has_type() const {
  return _internal_has_type();
}
inline void SolverParameter::clear_type() {
  _impl_.type_.ClearToDefault(::opencv_caffe::SolverParameter::Impl_::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& SolverParameter::type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.type)
  if (_impl_.type_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_type_.get();
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverParameter::set_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.type)
}
inline std::string* SolverParameter::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverParameter.type)
  return _s;
}
inline const std::string& SolverParameter::_internal_type() const {
  return _impl_.type_.Get();
}
inline void SolverParameter::_internal_set_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.type_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverParameter::_internal_mutable_type() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.type_.Mutable(::opencv_caffe::SolverParameter::Impl_::_i_give_permission_to_break_this_code_default_type_, GetArenaForAllocation());
}
inline std::string* SolverParameter::release_type() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverParameter.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.type_.Release();
  return p;
}
inline void SolverParameter::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverParameter.type)
}

// optional float delta = 31 [default = 1e-08];
inline bool SolverParameter::_internal_has_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool SolverParameter::has_delta() const {
  return _internal_has_delta();
}
inline void SolverParameter::clear_delta() {
  _impl_.delta_ = 1e-08f;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline float SolverParameter::_internal_delta() const {
  return _impl_.delta_;
}
inline float SolverParameter::delta() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.delta)
  return _internal_delta();
}
inline void SolverParameter::_internal_set_delta(float value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.delta_ = value;
}
inline void SolverParameter::set_delta(float value) {
  _internal_set_delta(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.delta)
}

// optional float momentum2 = 39 [default = 0.999];
inline bool SolverParameter::_internal_has_momentum2() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool SolverParameter::has_momentum2() const {
  return _internal_has_momentum2();
}
inline void SolverParameter::clear_momentum2() {
  _impl_.momentum2_ = 0.999f;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline float SolverParameter::_internal_momentum2() const {
  return _impl_.momentum2_;
}
inline float SolverParameter::momentum2() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.momentum2)
  return _internal_momentum2();
}
inline void SolverParameter::_internal_set_momentum2(float value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.momentum2_ = value;
}
inline void SolverParameter::set_momentum2(float value) {
  _internal_set_momentum2(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.momentum2)
}

// optional float rms_decay = 38 [default = 0.99];
inline bool SolverParameter::_internal_has_rms_decay() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool SolverParameter::has_rms_decay() const {
  return _internal_has_rms_decay();
}
inline void SolverParameter::clear_rms_decay() {
  _impl_.rms_decay_ = 0.99f;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline float SolverParameter::_internal_rms_decay() const {
  return _impl_.rms_decay_;
}
inline float SolverParameter::rms_decay() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.rms_decay)
  return _internal_rms_decay();
}
inline void SolverParameter::_internal_set_rms_decay(float value) {
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.rms_decay_ = value;
}
inline void SolverParameter::set_rms_decay(float value) {
  _internal_set_rms_decay(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.rms_decay)
}

// optional bool debug_info = 23 [default = false];
inline bool SolverParameter::_internal_has_debug_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool SolverParameter::has_debug_info() const {
  return _internal_has_debug_info();
}
inline void SolverParameter::clear_debug_info() {
  _impl_.debug_info_ = false;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline bool SolverParameter::_internal_debug_info() const {
  return _impl_.debug_info_;
}
inline bool SolverParameter::debug_info() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.debug_info)
  return _internal_debug_info();
}
inline void SolverParameter::_internal_set_debug_info(bool value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.debug_info_ = value;
}
inline void SolverParameter::set_debug_info(bool value) {
  _internal_set_debug_info(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.debug_info)
}

// optional bool snapshot_after_train = 28 [default = true];
inline bool SolverParameter::_internal_has_snapshot_after_train() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool SolverParameter::has_snapshot_after_train() const {
  return _internal_has_snapshot_after_train();
}
inline void SolverParameter::clear_snapshot_after_train() {
  _impl_.snapshot_after_train_ = true;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline bool SolverParameter::_internal_snapshot_after_train() const {
  return _impl_.snapshot_after_train_;
}
inline bool SolverParameter::snapshot_after_train() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.snapshot_after_train)
  return _internal_snapshot_after_train();
}
inline void SolverParameter::_internal_set_snapshot_after_train(bool value) {
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.snapshot_after_train_ = value;
}
inline void SolverParameter::set_snapshot_after_train(bool value) {
  _internal_set_snapshot_after_train(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.snapshot_after_train)
}

// optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
inline bool SolverParameter::_internal_has_solver_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool SolverParameter::has_solver_type() const {
  return _internal_has_solver_type();
}
inline void SolverParameter::clear_solver_type() {
  _impl_.solver_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline ::opencv_caffe::SolverParameter_SolverType SolverParameter::_internal_solver_type() const {
  return static_cast< ::opencv_caffe::SolverParameter_SolverType >(_impl_.solver_type_);
}
inline ::opencv_caffe::SolverParameter_SolverType SolverParameter::solver_type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverParameter.solver_type)
  return _internal_solver_type();
}
inline void SolverParameter::_internal_set_solver_type(::opencv_caffe::SolverParameter_SolverType value) {
  assert(::opencv_caffe::SolverParameter_SolverType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.solver_type_ = value;
}
inline void SolverParameter::set_solver_type(::opencv_caffe::SolverParameter_SolverType value) {
  _internal_set_solver_type(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverParameter.solver_type)
}

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

// SolverState

// optional int32 iter = 1;
inline bool SolverState::_internal_has_iter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SolverState::has_iter() const {
  return _internal_has_iter();
}
inline void SolverState::clear_iter() {
  _impl_.iter_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SolverState::_internal_iter() const {
  return _impl_.iter_;
}
inline int32_t SolverState::iter() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.iter)
  return _internal_iter();
}
inline void SolverState::_internal_set_iter(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.iter_ = value;
}
inline void SolverState::set_iter(int32_t value) {
  _internal_set_iter(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverState.iter)
}

// optional string learned_net = 2;
inline bool SolverState::_internal_has_learned_net() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SolverState::has_learned_net() const {
  return _internal_has_learned_net();
}
inline void SolverState::clear_learned_net() {
  _impl_.learned_net_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SolverState::learned_net() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.learned_net)
  return _internal_learned_net();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SolverState::set_learned_net(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.learned_net_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverState.learned_net)
}
inline std::string* SolverState::mutable_learned_net() {
  std::string* _s = _internal_mutable_learned_net();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverState.learned_net)
  return _s;
}
inline const std::string& SolverState::_internal_learned_net() const {
  return _impl_.learned_net_.Get();
}
inline void SolverState::_internal_set_learned_net(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.learned_net_.Set(value, GetArenaForAllocation());
}
inline std::string* SolverState::_internal_mutable_learned_net() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.learned_net_.Mutable(GetArenaForAllocation());
}
inline std::string* SolverState::release_learned_net() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SolverState.learned_net)
  if (!_internal_has_learned_net()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.learned_net_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.learned_net_.IsDefault()) {
    _impl_.learned_net_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SolverState::set_allocated_learned_net(std::string* learned_net) {
  if (learned_net != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.learned_net_.SetAllocated(learned_net, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.learned_net_.IsDefault()) {
    _impl_.learned_net_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SolverState.learned_net)
}

// repeated .opencv_caffe.BlobProto history = 3;
inline int SolverState::_internal_history_size() const {
  return _impl_.history_.size();
}
inline int SolverState::history_size() const {
  return _internal_history_size();
}
inline void SolverState::clear_history() {
  _impl_.history_.Clear();
}
inline ::opencv_caffe::BlobProto* SolverState::mutable_history(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SolverState.history)
  return _impl_.history_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
SolverState::mutable_history() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SolverState.history)
  return &_impl_.history_;
}
inline const ::opencv_caffe::BlobProto& SolverState::_internal_history(int index) const {
  return _impl_.history_.Get(index);
}
inline const ::opencv_caffe::BlobProto& SolverState::history(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.history)
  return _internal_history(index);
}
inline ::opencv_caffe::BlobProto* SolverState::_internal_add_history() {
  return _impl_.history_.Add();
}
inline ::opencv_caffe::BlobProto* SolverState::add_history() {
  ::opencv_caffe::BlobProto* _add = _internal_add_history();
  // @@protoc_insertion_point(field_add:opencv_caffe.SolverState.history)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
SolverState::history() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SolverState.history)
  return _impl_.history_;
}

// optional int32 current_step = 4 [default = 0];
inline bool SolverState::_internal_has_current_step() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SolverState::has_current_step() const {
  return _internal_has_current_step();
}
inline void SolverState::clear_current_step() {
  _impl_.current_step_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SolverState::_internal_current_step() const {
  return _impl_.current_step_;
}
inline int32_t SolverState::current_step() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SolverState.current_step)
  return _internal_current_step();
}
inline void SolverState::_internal_set_current_step(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.current_step_ = value;
}
inline void SolverState::set_current_step(int32_t value) {
  _internal_set_current_step(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SolverState.current_step)
}

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

// NetState

// optional .opencv_caffe.Phase phase = 1 [default = TEST];
inline bool NetState::_internal_has_phase() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NetState::has_phase() const {
  return _internal_has_phase();
}
inline void NetState::clear_phase() {
  _impl_.phase_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::opencv_caffe::Phase NetState::_internal_phase() const {
  return static_cast< ::opencv_caffe::Phase >(_impl_.phase_);
}
inline ::opencv_caffe::Phase NetState::phase() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetState.phase)
  return _internal_phase();
}
inline void NetState::_internal_set_phase(::opencv_caffe::Phase value) {
  assert(::opencv_caffe::Phase_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.phase_ = value;
}
inline void NetState::set_phase(::opencv_caffe::Phase value) {
  _internal_set_phase(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetState.phase)
}

// optional int32 level = 2 [default = 0];
inline bool NetState::_internal_has_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NetState::has_level() const {
  return _internal_has_level();
}
inline void NetState::clear_level() {
  _impl_.level_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t NetState::_internal_level() const {
  return _impl_.level_;
}
inline int32_t NetState::level() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetState.level)
  return _internal_level();
}
inline void NetState::_internal_set_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.level_ = value;
}
inline void NetState::set_level(int32_t value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetState.level)
}

// repeated string stage = 3;
inline int NetState::_internal_stage_size() const {
  return _impl_.stage_.size();
}
inline int NetState::stage_size() const {
  return _internal_stage_size();
}
inline void NetState::clear_stage() {
  _impl_.stage_.Clear();
}
inline std::string* NetState::add_stage() {
  std::string* _s = _internal_add_stage();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetState.stage)
  return _s;
}
inline const std::string& NetState::_internal_stage(int index) const {
  return _impl_.stage_.Get(index);
}
inline const std::string& NetState::stage(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetState.stage)
  return _internal_stage(index);
}
inline std::string* NetState::mutable_stage(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetState.stage)
  return _impl_.stage_.Mutable(index);
}
inline void NetState::set_stage(int index, const std::string& value) {
  _impl_.stage_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetState.stage)
}
inline void NetState::set_stage(int index, std::string&& value) {
  _impl_.stage_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.NetState.stage)
}
inline void NetState::set_stage(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.stage_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.NetState.stage)
}
inline void NetState::set_stage(int index, const char* value, size_t size) {
  _impl_.stage_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetState.stage)
}
inline std::string* NetState::_internal_add_stage() {
  return _impl_.stage_.Add();
}
inline void NetState::add_stage(const std::string& value) {
  _impl_.stage_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.NetState.stage)
}
inline void NetState::add_stage(std::string&& value) {
  _impl_.stage_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.NetState.stage)
}
inline void NetState::add_stage(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.stage_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.NetState.stage)
}
inline void NetState::add_stage(const char* value, size_t size) {
  _impl_.stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetState.stage)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetState::stage() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetState.stage)
  return _impl_.stage_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetState::mutable_stage() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetState.stage)
  return &_impl_.stage_;
}

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

// NetStateRule

// optional .opencv_caffe.Phase phase = 1;
inline bool NetStateRule::_internal_has_phase() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NetStateRule::has_phase() const {
  return _internal_has_phase();
}
inline void NetStateRule::clear_phase() {
  _impl_.phase_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::Phase NetStateRule::_internal_phase() const {
  return static_cast< ::opencv_caffe::Phase >(_impl_.phase_);
}
inline ::opencv_caffe::Phase NetStateRule::phase() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.phase)
  return _internal_phase();
}
inline void NetStateRule::_internal_set_phase(::opencv_caffe::Phase value) {
  assert(::opencv_caffe::Phase_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.phase_ = value;
}
inline void NetStateRule::set_phase(::opencv_caffe::Phase value) {
  _internal_set_phase(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.phase)
}

// optional int32 min_level = 2;
inline bool NetStateRule::_internal_has_min_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NetStateRule::has_min_level() const {
  return _internal_has_min_level();
}
inline void NetStateRule::clear_min_level() {
  _impl_.min_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t NetStateRule::_internal_min_level() const {
  return _impl_.min_level_;
}
inline int32_t NetStateRule::min_level() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.min_level)
  return _internal_min_level();
}
inline void NetStateRule::_internal_set_min_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.min_level_ = value;
}
inline void NetStateRule::set_min_level(int32_t value) {
  _internal_set_min_level(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.min_level)
}

// optional int32 max_level = 3;
inline bool NetStateRule::_internal_has_max_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NetStateRule::has_max_level() const {
  return _internal_has_max_level();
}
inline void NetStateRule::clear_max_level() {
  _impl_.max_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t NetStateRule::_internal_max_level() const {
  return _impl_.max_level_;
}
inline int32_t NetStateRule::max_level() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.max_level)
  return _internal_max_level();
}
inline void NetStateRule::_internal_set_max_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.max_level_ = value;
}
inline void NetStateRule::set_max_level(int32_t value) {
  _internal_set_max_level(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.max_level)
}

// repeated string stage = 4;
inline int NetStateRule::_internal_stage_size() const {
  return _impl_.stage_.size();
}
inline int NetStateRule::stage_size() const {
  return _internal_stage_size();
}
inline void NetStateRule::clear_stage() {
  _impl_.stage_.Clear();
}
inline std::string* NetStateRule::add_stage() {
  std::string* _s = _internal_add_stage();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetStateRule.stage)
  return _s;
}
inline const std::string& NetStateRule::_internal_stage(int index) const {
  return _impl_.stage_.Get(index);
}
inline const std::string& NetStateRule::stage(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.stage)
  return _internal_stage(index);
}
inline std::string* NetStateRule::mutable_stage(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetStateRule.stage)
  return _impl_.stage_.Mutable(index);
}
inline void NetStateRule::set_stage(int index, const std::string& value) {
  _impl_.stage_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, std::string&& value) {
  _impl_.stage_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.stage_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::set_stage(int index, const char* value, size_t size) {
  _impl_.stage_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetStateRule.stage)
}
inline std::string* NetStateRule::_internal_add_stage() {
  return _impl_.stage_.Add();
}
inline void NetStateRule::add_stage(const std::string& value) {
  _impl_.stage_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(std::string&& value) {
  _impl_.stage_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.stage_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.NetStateRule.stage)
}
inline void NetStateRule::add_stage(const char* value, size_t size) {
  _impl_.stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.stage)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetStateRule::stage() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.stage)
  return _impl_.stage_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetStateRule::mutable_stage() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.stage)
  return &_impl_.stage_;
}

// repeated string not_stage = 5;
inline int NetStateRule::_internal_not_stage_size() const {
  return _impl_.not_stage_.size();
}
inline int NetStateRule::not_stage_size() const {
  return _internal_not_stage_size();
}
inline void NetStateRule::clear_not_stage() {
  _impl_.not_stage_.Clear();
}
inline std::string* NetStateRule::add_not_stage() {
  std::string* _s = _internal_add_not_stage();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.NetStateRule.not_stage)
  return _s;
}
inline const std::string& NetStateRule::_internal_not_stage(int index) const {
  return _impl_.not_stage_.Get(index);
}
inline const std::string& NetStateRule::not_stage(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NetStateRule.not_stage)
  return _internal_not_stage(index);
}
inline std::string* NetStateRule::mutable_not_stage(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.NetStateRule.not_stage)
  return _impl_.not_stage_.Mutable(index);
}
inline void NetStateRule::set_not_stage(int index, const std::string& value) {
  _impl_.not_stage_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, std::string&& value) {
  _impl_.not_stage_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.not_stage_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::set_not_stage(int index, const char* value, size_t size) {
  _impl_.not_stage_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.NetStateRule.not_stage)
}
inline std::string* NetStateRule::_internal_add_not_stage() {
  return _impl_.not_stage_.Add();
}
inline void NetStateRule::add_not_stage(const std::string& value) {
  _impl_.not_stage_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(std::string&& value) {
  _impl_.not_stage_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.not_stage_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.NetStateRule.not_stage)
}
inline void NetStateRule::add_not_stage(const char* value, size_t size) {
  _impl_.not_stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.NetStateRule.not_stage)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetStateRule::not_stage() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.NetStateRule.not_stage)
  return _impl_.not_stage_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetStateRule::mutable_not_stage() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.NetStateRule.not_stage)
  return &_impl_.not_stage_;
}

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

// ParamSpec

// optional string name = 1;
inline bool ParamSpec::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ParamSpec::has_name() const {
  return _internal_has_name();
}
inline void ParamSpec::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ParamSpec::name() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ParamSpec::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.name)
}
inline std::string* ParamSpec::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ParamSpec.name)
  return _s;
}
inline const std::string& ParamSpec::_internal_name() const {
  return _impl_.name_.Get();
}
inline void ParamSpec::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* ParamSpec::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* ParamSpec::release_name() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ParamSpec.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ParamSpec::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ParamSpec.name)
}

// optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
inline bool ParamSpec::_internal_has_share_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ParamSpec::has_share_mode() const {
  return _internal_has_share_mode();
}
inline void ParamSpec::clear_share_mode() {
  _impl_.share_mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::opencv_caffe::ParamSpec_DimCheckMode ParamSpec::_internal_share_mode() const {
  return static_cast< ::opencv_caffe::ParamSpec_DimCheckMode >(_impl_.share_mode_);
}
inline ::opencv_caffe::ParamSpec_DimCheckMode ParamSpec::share_mode() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.share_mode)
  return _internal_share_mode();
}
inline void ParamSpec::_internal_set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value) {
  assert(::opencv_caffe::ParamSpec_DimCheckMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.share_mode_ = value;
}
inline void ParamSpec::set_share_mode(::opencv_caffe::ParamSpec_DimCheckMode value) {
  _internal_set_share_mode(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.share_mode)
}

// optional float lr_mult = 3 [default = 1];
inline bool ParamSpec::_internal_has_lr_mult() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ParamSpec::has_lr_mult() const {
  return _internal_has_lr_mult();
}
inline void ParamSpec::clear_lr_mult() {
  _impl_.lr_mult_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float ParamSpec::_internal_lr_mult() const {
  return _impl_.lr_mult_;
}
inline float ParamSpec::lr_mult() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.lr_mult)
  return _internal_lr_mult();
}
inline void ParamSpec::_internal_set_lr_mult(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.lr_mult_ = value;
}
inline void ParamSpec::set_lr_mult(float value) {
  _internal_set_lr_mult(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.lr_mult)
}

// optional float decay_mult = 4 [default = 1];
inline bool ParamSpec::_internal_has_decay_mult() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ParamSpec::has_decay_mult() const {
  return _internal_has_decay_mult();
}
inline void ParamSpec::clear_decay_mult() {
  _impl_.decay_mult_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float ParamSpec::_internal_decay_mult() const {
  return _impl_.decay_mult_;
}
inline float ParamSpec::decay_mult() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ParamSpec.decay_mult)
  return _internal_decay_mult();
}
inline void ParamSpec::_internal_set_decay_mult(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.decay_mult_ = value;
}
inline void ParamSpec::set_decay_mult(float value) {
  _internal_set_decay_mult(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ParamSpec.decay_mult)
}

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

// LayerParameter

// optional string name = 1;
inline bool LayerParameter::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LayerParameter::has_name() const {
  return _internal_has_name();
}
inline void LayerParameter::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LayerParameter::name() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerParameter::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.name)
}
inline std::string* LayerParameter::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.name)
  return _s;
}
inline const std::string& LayerParameter::_internal_name() const {
  return _impl_.name_.Get();
}
inline void LayerParameter::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* LayerParameter::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* LayerParameter::release_name() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LayerParameter::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.name)
}

// optional string type = 2;
inline bool LayerParameter::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LayerParameter::has_type() const {
  return _internal_has_type();
}
inline void LayerParameter::clear_type() {
  _impl_.type_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LayerParameter::type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LayerParameter::set_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.type)
}
inline std::string* LayerParameter::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.type)
  return _s;
}
inline const std::string& LayerParameter::_internal_type() const {
  return _impl_.type_.Get();
}
inline void LayerParameter::_internal_set_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_.Set(value, GetArenaForAllocation());
}
inline std::string* LayerParameter::_internal_mutable_type() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.type_.Mutable(GetArenaForAllocation());
}
inline std::string* LayerParameter::release_type() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.type_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LayerParameter::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.type)
}

// repeated string bottom = 3;
inline int LayerParameter::_internal_bottom_size() const {
  return _impl_.bottom_.size();
}
inline int LayerParameter::bottom_size() const {
  return _internal_bottom_size();
}
inline void LayerParameter::clear_bottom() {
  _impl_.bottom_.Clear();
}
inline std::string* LayerParameter::add_bottom() {
  std::string* _s = _internal_add_bottom();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.LayerParameter.bottom)
  return _s;
}
inline const std::string& LayerParameter::_internal_bottom(int index) const {
  return _impl_.bottom_.Get(index);
}
inline const std::string& LayerParameter::bottom(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.bottom)
  return _internal_bottom(index);
}
inline std::string* LayerParameter::mutable_bottom(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.bottom)
  return _impl_.bottom_.Mutable(index);
}
inline void LayerParameter::set_bottom(int index, const std::string& value) {
  _impl_.bottom_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, std::string&& value) {
  _impl_.bottom_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.bottom_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::set_bottom(int index, const char* value, size_t size) {
  _impl_.bottom_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.bottom)
}
inline std::string* LayerParameter::_internal_add_bottom() {
  return _impl_.bottom_.Add();
}
inline void LayerParameter::add_bottom(const std::string& value) {
  _impl_.bottom_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(std::string&& value) {
  _impl_.bottom_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.bottom_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.LayerParameter.bottom)
}
inline void LayerParameter::add_bottom(const char* value, size_t size) {
  _impl_.bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.bottom)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LayerParameter::bottom() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.bottom)
  return _impl_.bottom_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LayerParameter::mutable_bottom() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.bottom)
  return &_impl_.bottom_;
}

// repeated string top = 4;
inline int LayerParameter::_internal_top_size() const {
  return _impl_.top_.size();
}
inline int LayerParameter::top_size() const {
  return _internal_top_size();
}
inline void LayerParameter::clear_top() {
  _impl_.top_.Clear();
}
inline std::string* LayerParameter::add_top() {
  std::string* _s = _internal_add_top();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.LayerParameter.top)
  return _s;
}
inline const std::string& LayerParameter::_internal_top(int index) const {
  return _impl_.top_.Get(index);
}
inline const std::string& LayerParameter::top(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.top)
  return _internal_top(index);
}
inline std::string* LayerParameter::mutable_top(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.top)
  return _impl_.top_.Mutable(index);
}
inline void LayerParameter::set_top(int index, const std::string& value) {
  _impl_.top_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, std::string&& value) {
  _impl_.top_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.top_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::set_top(int index, const char* value, size_t size) {
  _impl_.top_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.LayerParameter.top)
}
inline std::string* LayerParameter::_internal_add_top() {
  return _impl_.top_.Add();
}
inline void LayerParameter::add_top(const std::string& value) {
  _impl_.top_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(std::string&& value) {
  _impl_.top_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.top_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.LayerParameter.top)
}
inline void LayerParameter::add_top(const char* value, size_t size) {
  _impl_.top_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.LayerParameter.top)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LayerParameter::top() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.top)
  return _impl_.top_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LayerParameter::mutable_top() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.top)
  return &_impl_.top_;
}

// optional .opencv_caffe.Phase phase = 10;
inline bool LayerParameter::_internal_has_phase() const {
  bool value = (_impl_._has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline bool LayerParameter::has_phase() const {
  return _internal_has_phase();
}
inline void LayerParameter::clear_phase() {
  _impl_.phase_ = 0;
  _impl_._has_bits_[1] &= ~0x01000000u;
}
inline ::opencv_caffe::Phase LayerParameter::_internal_phase() const {
  return static_cast< ::opencv_caffe::Phase >(_impl_.phase_);
}
inline ::opencv_caffe::Phase LayerParameter::phase() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.phase)
  return _internal_phase();
}
inline void LayerParameter::_internal_set_phase(::opencv_caffe::Phase value) {
  assert(::opencv_caffe::Phase_IsValid(value));
  _impl_._has_bits_[1] |= 0x01000000u;
  _impl_.phase_ = value;
}
inline void LayerParameter::set_phase(::opencv_caffe::Phase value) {
  _internal_set_phase(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.phase)
}

// repeated float loss_weight = 5;
inline int LayerParameter::_internal_loss_weight_size() const {
  return _impl_.loss_weight_.size();
}
inline int LayerParameter::loss_weight_size() const {
  return _internal_loss_weight_size();
}
inline void LayerParameter::clear_loss_weight() {
  _impl_.loss_weight_.Clear();
}
inline float LayerParameter::_internal_loss_weight(int index) const {
  return _impl_.loss_weight_.Get(index);
}
inline float LayerParameter::loss_weight(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.loss_weight)
  return _internal_loss_weight(index);
}
inline void LayerParameter::set_loss_weight(int index, float value) {
  _impl_.loss_weight_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.loss_weight)
}
inline void LayerParameter::_internal_add_loss_weight(float value) {
  _impl_.loss_weight_.Add(value);
}
inline void LayerParameter::add_loss_weight(float value) {
  _internal_add_loss_weight(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.loss_weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerParameter::_internal_loss_weight() const {
  return _impl_.loss_weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
LayerParameter::loss_weight() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.loss_weight)
  return _internal_loss_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerParameter::_internal_mutable_loss_weight() {
  return &_impl_.loss_weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
LayerParameter::mutable_loss_weight() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.loss_weight)
  return _internal_mutable_loss_weight();
}

// repeated .opencv_caffe.ParamSpec param = 6;
inline int LayerParameter::_internal_param_size() const {
  return _impl_.param_.size();
}
inline int LayerParameter::param_size() const {
  return _internal_param_size();
}
inline void LayerParameter::clear_param() {
  _impl_.param_.Clear();
}
inline ::opencv_caffe::ParamSpec* LayerParameter::mutable_param(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.param)
  return _impl_.param_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >*
LayerParameter::mutable_param() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.param)
  return &_impl_.param_;
}
inline const ::opencv_caffe::ParamSpec& LayerParameter::_internal_param(int index) const {
  return _impl_.param_.Get(index);
}
inline const ::opencv_caffe::ParamSpec& LayerParameter::param(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.param)
  return _internal_param(index);
}
inline ::opencv_caffe::ParamSpec* LayerParameter::_internal_add_param() {
  return _impl_.param_.Add();
}
inline ::opencv_caffe::ParamSpec* LayerParameter::add_param() {
  ::opencv_caffe::ParamSpec* _add = _internal_add_param();
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.param)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::ParamSpec >&
LayerParameter::param() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.param)
  return _impl_.param_;
}

// repeated .opencv_caffe.BlobProto blobs = 7;
inline int LayerParameter::_internal_blobs_size() const {
  return _impl_.blobs_.size();
}
inline int LayerParameter::blobs_size() const {
  return _internal_blobs_size();
}
inline void LayerParameter::clear_blobs() {
  _impl_.blobs_.Clear();
}
inline ::opencv_caffe::BlobProto* LayerParameter::mutable_blobs(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.blobs)
  return _impl_.blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
LayerParameter::mutable_blobs() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.blobs)
  return &_impl_.blobs_;
}
inline const ::opencv_caffe::BlobProto& LayerParameter::_internal_blobs(int index) const {
  return _impl_.blobs_.Get(index);
}
inline const ::opencv_caffe::BlobProto& LayerParameter::blobs(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.blobs)
  return _internal_blobs(index);
}
inline ::opencv_caffe::BlobProto* LayerParameter::_internal_add_blobs() {
  return _impl_.blobs_.Add();
}
inline ::opencv_caffe::BlobProto* LayerParameter::add_blobs() {
  ::opencv_caffe::BlobProto* _add = _internal_add_blobs();
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.blobs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
LayerParameter::blobs() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.blobs)
  return _impl_.blobs_;
}

// repeated bool propagate_down = 11;
inline int LayerParameter::_internal_propagate_down_size() const {
  return _impl_.propagate_down_.size();
}
inline int LayerParameter::propagate_down_size() const {
  return _internal_propagate_down_size();
}
inline void LayerParameter::clear_propagate_down() {
  _impl_.propagate_down_.Clear();
}
inline bool LayerParameter::_internal_propagate_down(int index) const {
  return _impl_.propagate_down_.Get(index);
}
inline bool LayerParameter::propagate_down(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.propagate_down)
  return _internal_propagate_down(index);
}
inline void LayerParameter::set_propagate_down(int index, bool value) {
  _impl_.propagate_down_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LayerParameter.propagate_down)
}
inline void LayerParameter::_internal_add_propagate_down(bool value) {
  _impl_.propagate_down_.Add(value);
}
inline void LayerParameter::add_propagate_down(bool value) {
  _internal_add_propagate_down(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.propagate_down)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
LayerParameter::_internal_propagate_down() const {
  return _impl_.propagate_down_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
LayerParameter::propagate_down() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.propagate_down)
  return _internal_propagate_down();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
LayerParameter::_internal_mutable_propagate_down() {
  return &_impl_.propagate_down_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
LayerParameter::mutable_propagate_down() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.propagate_down)
  return _internal_mutable_propagate_down();
}

// repeated .opencv_caffe.NetStateRule include = 8;
inline int LayerParameter::_internal_include_size() const {
  return _impl_.include_.size();
}
inline int LayerParameter::include_size() const {
  return _internal_include_size();
}
inline void LayerParameter::clear_include() {
  _impl_.include_.Clear();
}
inline ::opencv_caffe::NetStateRule* LayerParameter::mutable_include(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.include)
  return _impl_.include_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
LayerParameter::mutable_include() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.include)
  return &_impl_.include_;
}
inline const ::opencv_caffe::NetStateRule& LayerParameter::_internal_include(int index) const {
  return _impl_.include_.Get(index);
}
inline const ::opencv_caffe::NetStateRule& LayerParameter::include(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.include)
  return _internal_include(index);
}
inline ::opencv_caffe::NetStateRule* LayerParameter::_internal_add_include() {
  return _impl_.include_.Add();
}
inline ::opencv_caffe::NetStateRule* LayerParameter::add_include() {
  ::opencv_caffe::NetStateRule* _add = _internal_add_include();
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.include)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
LayerParameter::include() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.include)
  return _impl_.include_;
}

// repeated .opencv_caffe.NetStateRule exclude = 9;
inline int LayerParameter::_internal_exclude_size() const {
  return _impl_.exclude_.size();
}
inline int LayerParameter::exclude_size() const {
  return _internal_exclude_size();
}
inline void LayerParameter::clear_exclude() {
  _impl_.exclude_.Clear();
}
inline ::opencv_caffe::NetStateRule* LayerParameter::mutable_exclude(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.exclude)
  return _impl_.exclude_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
LayerParameter::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.LayerParameter.exclude)
  return &_impl_.exclude_;
}
inline const ::opencv_caffe::NetStateRule& LayerParameter::_internal_exclude(int index) const {
  return _impl_.exclude_.Get(index);
}
inline const ::opencv_caffe::NetStateRule& LayerParameter::exclude(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.exclude)
  return _internal_exclude(index);
}
inline ::opencv_caffe::NetStateRule* LayerParameter::_internal_add_exclude() {
  return _impl_.exclude_.Add();
}
inline ::opencv_caffe::NetStateRule* LayerParameter::add_exclude() {
  ::opencv_caffe::NetStateRule* _add = _internal_add_exclude();
  // @@protoc_insertion_point(field_add:opencv_caffe.LayerParameter.exclude)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
LayerParameter::exclude() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.LayerParameter.exclude)
  return _impl_.exclude_;
}

// optional .opencv_caffe.TransformationParameter transform_param = 100;
inline bool LayerParameter::_internal_has_transform_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.transform_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_transform_param() const {
  return _internal_has_transform_param();
}
inline void LayerParameter::clear_transform_param() {
  if (_impl_.transform_param_ != nullptr) _impl_.transform_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::opencv_caffe::TransformationParameter& LayerParameter::_internal_transform_param() const {
  const ::opencv_caffe::TransformationParameter* p = _impl_.transform_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::TransformationParameter&>(
      ::opencv_caffe::_TransformationParameter_default_instance_);
}
inline const ::opencv_caffe::TransformationParameter& LayerParameter::transform_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.transform_param)
  return _internal_transform_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_transform_param(
    ::opencv_caffe::TransformationParameter* transform_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transform_param_);
  }
  _impl_.transform_param_ = transform_param;
  if (transform_param) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.transform_param)
}
inline ::opencv_caffe::TransformationParameter* LayerParameter::release_transform_param() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::opencv_caffe::TransformationParameter* temp = _impl_.transform_param_;
  _impl_.transform_param_ = 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 ::opencv_caffe::TransformationParameter* LayerParameter::unsafe_arena_release_transform_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.transform_param)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::opencv_caffe::TransformationParameter* temp = _impl_.transform_param_;
  _impl_.transform_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::TransformationParameter* LayerParameter::_internal_mutable_transform_param() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.transform_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::TransformationParameter>(GetArenaForAllocation());
    _impl_.transform_param_ = p;
  }
  return _impl_.transform_param_;
}
inline ::opencv_caffe::TransformationParameter* LayerParameter::mutable_transform_param() {
  ::opencv_caffe::TransformationParameter* _msg = _internal_mutable_transform_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.transform_param)
  return _msg;
}
inline void LayerParameter::set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.transform_param_;
  }
  if (transform_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(transform_param);
    if (message_arena != submessage_arena) {
      transform_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, transform_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.transform_param_ = transform_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.transform_param)
}

// optional .opencv_caffe.LossParameter loss_param = 101;
inline bool LayerParameter::_internal_has_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.loss_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_loss_param() const {
  return _internal_has_loss_param();
}
inline void LayerParameter::clear_loss_param() {
  if (_impl_.loss_param_ != nullptr) _impl_.loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::opencv_caffe::LossParameter& LayerParameter::_internal_loss_param() const {
  const ::opencv_caffe::LossParameter* p = _impl_.loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::LossParameter&>(
      ::opencv_caffe::_LossParameter_default_instance_);
}
inline const ::opencv_caffe::LossParameter& LayerParameter::loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.loss_param)
  return _internal_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_loss_param(
    ::opencv_caffe::LossParameter* loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.loss_param_);
  }
  _impl_.loss_param_ = loss_param;
  if (loss_param) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.loss_param)
}
inline ::opencv_caffe::LossParameter* LayerParameter::release_loss_param() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::opencv_caffe::LossParameter* temp = _impl_.loss_param_;
  _impl_.loss_param_ = 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 ::opencv_caffe::LossParameter* LayerParameter::unsafe_arena_release_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.loss_param)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::opencv_caffe::LossParameter* temp = _impl_.loss_param_;
  _impl_.loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::LossParameter* LayerParameter::_internal_mutable_loss_param() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::LossParameter>(GetArenaForAllocation());
    _impl_.loss_param_ = p;
  }
  return _impl_.loss_param_;
}
inline ::opencv_caffe::LossParameter* LayerParameter::mutable_loss_param() {
  ::opencv_caffe::LossParameter* _msg = _internal_mutable_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.loss_param)
  return _msg;
}
inline void LayerParameter::set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.loss_param_;
  }
  if (loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(loss_param);
    if (message_arena != submessage_arena) {
      loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.loss_param_ = loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.loss_param)
}

// optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
inline bool LayerParameter::_internal_has_accuracy_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.accuracy_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_accuracy_param() const {
  return _internal_has_accuracy_param();
}
inline void LayerParameter::clear_accuracy_param() {
  if (_impl_.accuracy_param_ != nullptr) _impl_.accuracy_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::opencv_caffe::AccuracyParameter& LayerParameter::_internal_accuracy_param() const {
  const ::opencv_caffe::AccuracyParameter* p = _impl_.accuracy_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::AccuracyParameter&>(
      ::opencv_caffe::_AccuracyParameter_default_instance_);
}
inline const ::opencv_caffe::AccuracyParameter& LayerParameter::accuracy_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.accuracy_param)
  return _internal_accuracy_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_accuracy_param(
    ::opencv_caffe::AccuracyParameter* accuracy_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.accuracy_param_);
  }
  _impl_.accuracy_param_ = accuracy_param;
  if (accuracy_param) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.accuracy_param)
}
inline ::opencv_caffe::AccuracyParameter* LayerParameter::release_accuracy_param() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::opencv_caffe::AccuracyParameter* temp = _impl_.accuracy_param_;
  _impl_.accuracy_param_ = 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 ::opencv_caffe::AccuracyParameter* LayerParameter::unsafe_arena_release_accuracy_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.accuracy_param)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::opencv_caffe::AccuracyParameter* temp = _impl_.accuracy_param_;
  _impl_.accuracy_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::AccuracyParameter* LayerParameter::_internal_mutable_accuracy_param() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.accuracy_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::AccuracyParameter>(GetArenaForAllocation());
    _impl_.accuracy_param_ = p;
  }
  return _impl_.accuracy_param_;
}
inline ::opencv_caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() {
  ::opencv_caffe::AccuracyParameter* _msg = _internal_mutable_accuracy_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.accuracy_param)
  return _msg;
}
inline void LayerParameter::set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.accuracy_param_;
  }
  if (accuracy_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(accuracy_param);
    if (message_arena != submessage_arena) {
      accuracy_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, accuracy_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.accuracy_param_ = accuracy_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.accuracy_param)
}

// optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
inline bool LayerParameter::_internal_has_argmax_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.argmax_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_argmax_param() const {
  return _internal_has_argmax_param();
}
inline void LayerParameter::clear_argmax_param() {
  if (_impl_.argmax_param_ != nullptr) _impl_.argmax_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::opencv_caffe::ArgMaxParameter& LayerParameter::_internal_argmax_param() const {
  const ::opencv_caffe::ArgMaxParameter* p = _impl_.argmax_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ArgMaxParameter&>(
      ::opencv_caffe::_ArgMaxParameter_default_instance_);
}
inline const ::opencv_caffe::ArgMaxParameter& LayerParameter::argmax_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.argmax_param)
  return _internal_argmax_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_argmax_param(
    ::opencv_caffe::ArgMaxParameter* argmax_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.argmax_param_);
  }
  _impl_.argmax_param_ = argmax_param;
  if (argmax_param) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.argmax_param)
}
inline ::opencv_caffe::ArgMaxParameter* LayerParameter::release_argmax_param() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::opencv_caffe::ArgMaxParameter* temp = _impl_.argmax_param_;
  _impl_.argmax_param_ = 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 ::opencv_caffe::ArgMaxParameter* LayerParameter::unsafe_arena_release_argmax_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.argmax_param)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::opencv_caffe::ArgMaxParameter* temp = _impl_.argmax_param_;
  _impl_.argmax_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ArgMaxParameter* LayerParameter::_internal_mutable_argmax_param() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.argmax_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ArgMaxParameter>(GetArenaForAllocation());
    _impl_.argmax_param_ = p;
  }
  return _impl_.argmax_param_;
}
inline ::opencv_caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() {
  ::opencv_caffe::ArgMaxParameter* _msg = _internal_mutable_argmax_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.argmax_param)
  return _msg;
}
inline void LayerParameter::set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.argmax_param_;
  }
  if (argmax_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(argmax_param);
    if (message_arena != submessage_arena) {
      argmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, argmax_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.argmax_param_ = argmax_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.argmax_param)
}

// optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
inline bool LayerParameter::_internal_has_batch_norm_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.batch_norm_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_batch_norm_param() const {
  return _internal_has_batch_norm_param();
}
inline void LayerParameter::clear_batch_norm_param() {
  if (_impl_.batch_norm_param_ != nullptr) _impl_.batch_norm_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline const ::opencv_caffe::BatchNormParameter& LayerParameter::_internal_batch_norm_param() const {
  const ::opencv_caffe::BatchNormParameter* p = _impl_.batch_norm_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::BatchNormParameter&>(
      ::opencv_caffe::_BatchNormParameter_default_instance_);
}
inline const ::opencv_caffe::BatchNormParameter& LayerParameter::batch_norm_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.batch_norm_param)
  return _internal_batch_norm_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_batch_norm_param(
    ::opencv_caffe::BatchNormParameter* batch_norm_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.batch_norm_param_);
  }
  _impl_.batch_norm_param_ = batch_norm_param;
  if (batch_norm_param) {
    _impl_._has_bits_[1] |= 0x00000200u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.batch_norm_param)
}
inline ::opencv_caffe::BatchNormParameter* LayerParameter::release_batch_norm_param() {
  _impl_._has_bits_[1] &= ~0x00000200u;
  ::opencv_caffe::BatchNormParameter* temp = _impl_.batch_norm_param_;
  _impl_.batch_norm_param_ = 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 ::opencv_caffe::BatchNormParameter* LayerParameter::unsafe_arena_release_batch_norm_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.batch_norm_param)
  _impl_._has_bits_[1] &= ~0x00000200u;
  ::opencv_caffe::BatchNormParameter* temp = _impl_.batch_norm_param_;
  _impl_.batch_norm_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::BatchNormParameter* LayerParameter::_internal_mutable_batch_norm_param() {
  _impl_._has_bits_[1] |= 0x00000200u;
  if (_impl_.batch_norm_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::BatchNormParameter>(GetArenaForAllocation());
    _impl_.batch_norm_param_ = p;
  }
  return _impl_.batch_norm_param_;
}
inline ::opencv_caffe::BatchNormParameter* LayerParameter::mutable_batch_norm_param() {
  ::opencv_caffe::BatchNormParameter* _msg = _internal_mutable_batch_norm_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.batch_norm_param)
  return _msg;
}
inline void LayerParameter::set_allocated_batch_norm_param(::opencv_caffe::BatchNormParameter* batch_norm_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.batch_norm_param_;
  }
  if (batch_norm_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(batch_norm_param);
    if (message_arena != submessage_arena) {
      batch_norm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, batch_norm_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000200u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000200u;
  }
  _impl_.batch_norm_param_ = batch_norm_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.batch_norm_param)
}

// optional .opencv_caffe.BiasParameter bias_param = 141;
inline bool LayerParameter::_internal_has_bias_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_bias_param() const {
  return _internal_has_bias_param();
}
inline void LayerParameter::clear_bias_param() {
  if (_impl_.bias_param_ != nullptr) _impl_.bias_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline const ::opencv_caffe::BiasParameter& LayerParameter::_internal_bias_param() const {
  const ::opencv_caffe::BiasParameter* p = _impl_.bias_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::BiasParameter&>(
      ::opencv_caffe::_BiasParameter_default_instance_);
}
inline const ::opencv_caffe::BiasParameter& LayerParameter::bias_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.bias_param)
  return _internal_bias_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_bias_param(
    ::opencv_caffe::BiasParameter* bias_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_param_);
  }
  _impl_.bias_param_ = bias_param;
  if (bias_param) {
    _impl_._has_bits_[1] |= 0x00000800u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.bias_param)
}
inline ::opencv_caffe::BiasParameter* LayerParameter::release_bias_param() {
  _impl_._has_bits_[1] &= ~0x00000800u;
  ::opencv_caffe::BiasParameter* temp = _impl_.bias_param_;
  _impl_.bias_param_ = 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 ::opencv_caffe::BiasParameter* LayerParameter::unsafe_arena_release_bias_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.bias_param)
  _impl_._has_bits_[1] &= ~0x00000800u;
  ::opencv_caffe::BiasParameter* temp = _impl_.bias_param_;
  _impl_.bias_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::BiasParameter* LayerParameter::_internal_mutable_bias_param() {
  _impl_._has_bits_[1] |= 0x00000800u;
  if (_impl_.bias_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::BiasParameter>(GetArenaForAllocation());
    _impl_.bias_param_ = p;
  }
  return _impl_.bias_param_;
}
inline ::opencv_caffe::BiasParameter* LayerParameter::mutable_bias_param() {
  ::opencv_caffe::BiasParameter* _msg = _internal_mutable_bias_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.bias_param)
  return _msg;
}
inline void LayerParameter::set_allocated_bias_param(::opencv_caffe::BiasParameter* bias_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_param_;
  }
  if (bias_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_param);
    if (message_arena != submessage_arena) {
      bias_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000800u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000800u;
  }
  _impl_.bias_param_ = bias_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.bias_param)
}

// optional .opencv_caffe.ConcatParameter concat_param = 104;
inline bool LayerParameter::_internal_has_concat_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.concat_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_concat_param() const {
  return _internal_has_concat_param();
}
inline void LayerParameter::clear_concat_param() {
  if (_impl_.concat_param_ != nullptr) _impl_.concat_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::opencv_caffe::ConcatParameter& LayerParameter::_internal_concat_param() const {
  const ::opencv_caffe::ConcatParameter* p = _impl_.concat_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ConcatParameter&>(
      ::opencv_caffe::_ConcatParameter_default_instance_);
}
inline const ::opencv_caffe::ConcatParameter& LayerParameter::concat_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.concat_param)
  return _internal_concat_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_concat_param(
    ::opencv_caffe::ConcatParameter* concat_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.concat_param_);
  }
  _impl_.concat_param_ = concat_param;
  if (concat_param) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.concat_param)
}
inline ::opencv_caffe::ConcatParameter* LayerParameter::release_concat_param() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::ConcatParameter* temp = _impl_.concat_param_;
  _impl_.concat_param_ = 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 ::opencv_caffe::ConcatParameter* LayerParameter::unsafe_arena_release_concat_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.concat_param)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::ConcatParameter* temp = _impl_.concat_param_;
  _impl_.concat_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ConcatParameter* LayerParameter::_internal_mutable_concat_param() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.concat_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ConcatParameter>(GetArenaForAllocation());
    _impl_.concat_param_ = p;
  }
  return _impl_.concat_param_;
}
inline ::opencv_caffe::ConcatParameter* LayerParameter::mutable_concat_param() {
  ::opencv_caffe::ConcatParameter* _msg = _internal_mutable_concat_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.concat_param)
  return _msg;
}
inline void LayerParameter::set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.concat_param_;
  }
  if (concat_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(concat_param);
    if (message_arena != submessage_arena) {
      concat_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, concat_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.concat_param_ = concat_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.concat_param)
}

// optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
inline bool LayerParameter::_internal_has_contrastive_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contrastive_loss_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_contrastive_loss_param() const {
  return _internal_has_contrastive_loss_param();
}
inline void LayerParameter::clear_contrastive_loss_param() {
  if (_impl_.contrastive_loss_param_ != nullptr) _impl_.contrastive_loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::opencv_caffe::ContrastiveLossParameter& LayerParameter::_internal_contrastive_loss_param() const {
  const ::opencv_caffe::ContrastiveLossParameter* p = _impl_.contrastive_loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ContrastiveLossParameter&>(
      ::opencv_caffe::_ContrastiveLossParameter_default_instance_);
}
inline const ::opencv_caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.contrastive_loss_param)
  return _internal_contrastive_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_contrastive_loss_param(
    ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contrastive_loss_param_);
  }
  _impl_.contrastive_loss_param_ = contrastive_loss_param;
  if (contrastive_loss_param) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.contrastive_loss_param)
}
inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::ContrastiveLossParameter* temp = _impl_.contrastive_loss_param_;
  _impl_.contrastive_loss_param_ = 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 ::opencv_caffe::ContrastiveLossParameter* LayerParameter::unsafe_arena_release_contrastive_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.contrastive_loss_param)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::ContrastiveLossParameter* temp = _impl_.contrastive_loss_param_;
  _impl_.contrastive_loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::_internal_mutable_contrastive_loss_param() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.contrastive_loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ContrastiveLossParameter>(GetArenaForAllocation());
    _impl_.contrastive_loss_param_ = p;
  }
  return _impl_.contrastive_loss_param_;
}
inline ::opencv_caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() {
  ::opencv_caffe::ContrastiveLossParameter* _msg = _internal_mutable_contrastive_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.contrastive_loss_param)
  return _msg;
}
inline void LayerParameter::set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contrastive_loss_param_;
  }
  if (contrastive_loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contrastive_loss_param);
    if (message_arena != submessage_arena) {
      contrastive_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contrastive_loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.contrastive_loss_param_ = contrastive_loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.contrastive_loss_param)
}

// optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
inline bool LayerParameter::_internal_has_convolution_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.convolution_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_convolution_param() const {
  return _internal_has_convolution_param();
}
inline void LayerParameter::clear_convolution_param() {
  if (_impl_.convolution_param_ != nullptr) _impl_.convolution_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::opencv_caffe::ConvolutionParameter& LayerParameter::_internal_convolution_param() const {
  const ::opencv_caffe::ConvolutionParameter* p = _impl_.convolution_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ConvolutionParameter&>(
      ::opencv_caffe::_ConvolutionParameter_default_instance_);
}
inline const ::opencv_caffe::ConvolutionParameter& LayerParameter::convolution_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.convolution_param)
  return _internal_convolution_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_convolution_param(
    ::opencv_caffe::ConvolutionParameter* convolution_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.convolution_param_);
  }
  _impl_.convolution_param_ = convolution_param;
  if (convolution_param) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.convolution_param)
}
inline ::opencv_caffe::ConvolutionParameter* LayerParameter::release_convolution_param() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::opencv_caffe::ConvolutionParameter* temp = _impl_.convolution_param_;
  _impl_.convolution_param_ = 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 ::opencv_caffe::ConvolutionParameter* LayerParameter::unsafe_arena_release_convolution_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.convolution_param)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::opencv_caffe::ConvolutionParameter* temp = _impl_.convolution_param_;
  _impl_.convolution_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ConvolutionParameter* LayerParameter::_internal_mutable_convolution_param() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.convolution_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ConvolutionParameter>(GetArenaForAllocation());
    _impl_.convolution_param_ = p;
  }
  return _impl_.convolution_param_;
}
inline ::opencv_caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() {
  ::opencv_caffe::ConvolutionParameter* _msg = _internal_mutable_convolution_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.convolution_param)
  return _msg;
}
inline void LayerParameter::set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.convolution_param_;
  }
  if (convolution_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(convolution_param);
    if (message_arena != submessage_arena) {
      convolution_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, convolution_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.convolution_param_ = convolution_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.convolution_param)
}

// optional .opencv_caffe.CropParameter crop_param = 144;
inline bool LayerParameter::_internal_has_crop_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.crop_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_crop_param() const {
  return _internal_has_crop_param();
}
inline void LayerParameter::clear_crop_param() {
  if (_impl_.crop_param_ != nullptr) _impl_.crop_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00004000u;
}
inline const ::opencv_caffe::CropParameter& LayerParameter::_internal_crop_param() const {
  const ::opencv_caffe::CropParameter* p = _impl_.crop_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::CropParameter&>(
      ::opencv_caffe::_CropParameter_default_instance_);
}
inline const ::opencv_caffe::CropParameter& LayerParameter::crop_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.crop_param)
  return _internal_crop_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_crop_param(
    ::opencv_caffe::CropParameter* crop_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.crop_param_);
  }
  _impl_.crop_param_ = crop_param;
  if (crop_param) {
    _impl_._has_bits_[1] |= 0x00004000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.crop_param)
}
inline ::opencv_caffe::CropParameter* LayerParameter::release_crop_param() {
  _impl_._has_bits_[1] &= ~0x00004000u;
  ::opencv_caffe::CropParameter* temp = _impl_.crop_param_;
  _impl_.crop_param_ = 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 ::opencv_caffe::CropParameter* LayerParameter::unsafe_arena_release_crop_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.crop_param)
  _impl_._has_bits_[1] &= ~0x00004000u;
  ::opencv_caffe::CropParameter* temp = _impl_.crop_param_;
  _impl_.crop_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::CropParameter* LayerParameter::_internal_mutable_crop_param() {
  _impl_._has_bits_[1] |= 0x00004000u;
  if (_impl_.crop_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::CropParameter>(GetArenaForAllocation());
    _impl_.crop_param_ = p;
  }
  return _impl_.crop_param_;
}
inline ::opencv_caffe::CropParameter* LayerParameter::mutable_crop_param() {
  ::opencv_caffe::CropParameter* _msg = _internal_mutable_crop_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.crop_param)
  return _msg;
}
inline void LayerParameter::set_allocated_crop_param(::opencv_caffe::CropParameter* crop_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.crop_param_;
  }
  if (crop_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(crop_param);
    if (message_arena != submessage_arena) {
      crop_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, crop_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00004000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00004000u;
  }
  _impl_.crop_param_ = crop_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.crop_param)
}

// optional .opencv_caffe.DataParameter data_param = 107;
inline bool LayerParameter::_internal_has_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_data_param() const {
  return _internal_has_data_param();
}
inline void LayerParameter::clear_data_param() {
  if (_impl_.data_param_ != nullptr) _impl_.data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::opencv_caffe::DataParameter& LayerParameter::_internal_data_param() const {
  const ::opencv_caffe::DataParameter* p = _impl_.data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DataParameter&>(
      ::opencv_caffe::_DataParameter_default_instance_);
}
inline const ::opencv_caffe::DataParameter& LayerParameter::data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.data_param)
  return _internal_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_data_param(
    ::opencv_caffe::DataParameter* data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.data_param_);
  }
  _impl_.data_param_ = data_param;
  if (data_param) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.data_param)
}
inline ::opencv_caffe::DataParameter* LayerParameter::release_data_param() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::opencv_caffe::DataParameter* temp = _impl_.data_param_;
  _impl_.data_param_ = 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 ::opencv_caffe::DataParameter* LayerParameter::unsafe_arena_release_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.data_param)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::opencv_caffe::DataParameter* temp = _impl_.data_param_;
  _impl_.data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DataParameter* LayerParameter::_internal_mutable_data_param() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DataParameter>(GetArenaForAllocation());
    _impl_.data_param_ = p;
  }
  return _impl_.data_param_;
}
inline ::opencv_caffe::DataParameter* LayerParameter::mutable_data_param() {
  ::opencv_caffe::DataParameter* _msg = _internal_mutable_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.data_param)
  return _msg;
}
inline void LayerParameter::set_allocated_data_param(::opencv_caffe::DataParameter* data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.data_param_;
  }
  if (data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data_param);
    if (message_arena != submessage_arena) {
      data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.data_param_ = data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.data_param)
}

// optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
inline bool LayerParameter::_internal_has_detection_output_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.detection_output_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_detection_output_param() const {
  return _internal_has_detection_output_param();
}
inline void LayerParameter::clear_detection_output_param() {
  if (_impl_.detection_output_param_ != nullptr) _impl_.detection_output_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00020000u;
}
inline const ::opencv_caffe::DetectionOutputParameter& LayerParameter::_internal_detection_output_param() const {
  const ::opencv_caffe::DetectionOutputParameter* p = _impl_.detection_output_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DetectionOutputParameter&>(
      ::opencv_caffe::_DetectionOutputParameter_default_instance_);
}
inline const ::opencv_caffe::DetectionOutputParameter& LayerParameter::detection_output_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.detection_output_param)
  return _internal_detection_output_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_detection_output_param(
    ::opencv_caffe::DetectionOutputParameter* detection_output_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.detection_output_param_);
  }
  _impl_.detection_output_param_ = detection_output_param;
  if (detection_output_param) {
    _impl_._has_bits_[1] |= 0x00020000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.detection_output_param)
}
inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::release_detection_output_param() {
  _impl_._has_bits_[1] &= ~0x00020000u;
  ::opencv_caffe::DetectionOutputParameter* temp = _impl_.detection_output_param_;
  _impl_.detection_output_param_ = 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 ::opencv_caffe::DetectionOutputParameter* LayerParameter::unsafe_arena_release_detection_output_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.detection_output_param)
  _impl_._has_bits_[1] &= ~0x00020000u;
  ::opencv_caffe::DetectionOutputParameter* temp = _impl_.detection_output_param_;
  _impl_.detection_output_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::_internal_mutable_detection_output_param() {
  _impl_._has_bits_[1] |= 0x00020000u;
  if (_impl_.detection_output_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DetectionOutputParameter>(GetArenaForAllocation());
    _impl_.detection_output_param_ = p;
  }
  return _impl_.detection_output_param_;
}
inline ::opencv_caffe::DetectionOutputParameter* LayerParameter::mutable_detection_output_param() {
  ::opencv_caffe::DetectionOutputParameter* _msg = _internal_mutable_detection_output_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.detection_output_param)
  return _msg;
}
inline void LayerParameter::set_allocated_detection_output_param(::opencv_caffe::DetectionOutputParameter* detection_output_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.detection_output_param_;
  }
  if (detection_output_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(detection_output_param);
    if (message_arena != submessage_arena) {
      detection_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, detection_output_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00020000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00020000u;
  }
  _impl_.detection_output_param_ = detection_output_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.detection_output_param)
}

// optional .opencv_caffe.DropoutParameter dropout_param = 108;
inline bool LayerParameter::_internal_has_dropout_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dropout_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_dropout_param() const {
  return _internal_has_dropout_param();
}
inline void LayerParameter::clear_dropout_param() {
  if (_impl_.dropout_param_ != nullptr) _impl_.dropout_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::opencv_caffe::DropoutParameter& LayerParameter::_internal_dropout_param() const {
  const ::opencv_caffe::DropoutParameter* p = _impl_.dropout_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DropoutParameter&>(
      ::opencv_caffe::_DropoutParameter_default_instance_);
}
inline const ::opencv_caffe::DropoutParameter& LayerParameter::dropout_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.dropout_param)
  return _internal_dropout_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_dropout_param(
    ::opencv_caffe::DropoutParameter* dropout_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dropout_param_);
  }
  _impl_.dropout_param_ = dropout_param;
  if (dropout_param) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.dropout_param)
}
inline ::opencv_caffe::DropoutParameter* LayerParameter::release_dropout_param() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::opencv_caffe::DropoutParameter* temp = _impl_.dropout_param_;
  _impl_.dropout_param_ = 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 ::opencv_caffe::DropoutParameter* LayerParameter::unsafe_arena_release_dropout_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.dropout_param)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::opencv_caffe::DropoutParameter* temp = _impl_.dropout_param_;
  _impl_.dropout_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DropoutParameter* LayerParameter::_internal_mutable_dropout_param() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.dropout_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DropoutParameter>(GetArenaForAllocation());
    _impl_.dropout_param_ = p;
  }
  return _impl_.dropout_param_;
}
inline ::opencv_caffe::DropoutParameter* LayerParameter::mutable_dropout_param() {
  ::opencv_caffe::DropoutParameter* _msg = _internal_mutable_dropout_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.dropout_param)
  return _msg;
}
inline void LayerParameter::set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dropout_param_;
  }
  if (dropout_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dropout_param);
    if (message_arena != submessage_arena) {
      dropout_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dropout_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.dropout_param_ = dropout_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.dropout_param)
}

// optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
inline bool LayerParameter::_internal_has_dummy_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dummy_data_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_dummy_data_param() const {
  return _internal_has_dummy_data_param();
}
inline void LayerParameter::clear_dummy_data_param() {
  if (_impl_.dummy_data_param_ != nullptr) _impl_.dummy_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::opencv_caffe::DummyDataParameter& LayerParameter::_internal_dummy_data_param() const {
  const ::opencv_caffe::DummyDataParameter* p = _impl_.dummy_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DummyDataParameter&>(
      ::opencv_caffe::_DummyDataParameter_default_instance_);
}
inline const ::opencv_caffe::DummyDataParameter& LayerParameter::dummy_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.dummy_data_param)
  return _internal_dummy_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_dummy_data_param(
    ::opencv_caffe::DummyDataParameter* dummy_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dummy_data_param_);
  }
  _impl_.dummy_data_param_ = dummy_data_param;
  if (dummy_data_param) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.dummy_data_param)
}
inline ::opencv_caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::opencv_caffe::DummyDataParameter* temp = _impl_.dummy_data_param_;
  _impl_.dummy_data_param_ = 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 ::opencv_caffe::DummyDataParameter* LayerParameter::unsafe_arena_release_dummy_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.dummy_data_param)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::opencv_caffe::DummyDataParameter* temp = _impl_.dummy_data_param_;
  _impl_.dummy_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DummyDataParameter* LayerParameter::_internal_mutable_dummy_data_param() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.dummy_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DummyDataParameter>(GetArenaForAllocation());
    _impl_.dummy_data_param_ = p;
  }
  return _impl_.dummy_data_param_;
}
inline ::opencv_caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() {
  ::opencv_caffe::DummyDataParameter* _msg = _internal_mutable_dummy_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.dummy_data_param)
  return _msg;
}
inline void LayerParameter::set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dummy_data_param_;
  }
  if (dummy_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dummy_data_param);
    if (message_arena != submessage_arena) {
      dummy_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dummy_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.dummy_data_param_ = dummy_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.dummy_data_param)
}

// optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
inline bool LayerParameter::_internal_has_eltwise_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.eltwise_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_eltwise_param() const {
  return _internal_has_eltwise_param();
}
inline void LayerParameter::clear_eltwise_param() {
  if (_impl_.eltwise_param_ != nullptr) _impl_.eltwise_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::opencv_caffe::EltwiseParameter& LayerParameter::_internal_eltwise_param() const {
  const ::opencv_caffe::EltwiseParameter* p = _impl_.eltwise_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::EltwiseParameter&>(
      ::opencv_caffe::_EltwiseParameter_default_instance_);
}
inline const ::opencv_caffe::EltwiseParameter& LayerParameter::eltwise_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.eltwise_param)
  return _internal_eltwise_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_eltwise_param(
    ::opencv_caffe::EltwiseParameter* eltwise_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.eltwise_param_);
  }
  _impl_.eltwise_param_ = eltwise_param;
  if (eltwise_param) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.eltwise_param)
}
inline ::opencv_caffe::EltwiseParameter* LayerParameter::release_eltwise_param() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::opencv_caffe::EltwiseParameter* temp = _impl_.eltwise_param_;
  _impl_.eltwise_param_ = 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 ::opencv_caffe::EltwiseParameter* LayerParameter::unsafe_arena_release_eltwise_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.eltwise_param)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::opencv_caffe::EltwiseParameter* temp = _impl_.eltwise_param_;
  _impl_.eltwise_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::EltwiseParameter* LayerParameter::_internal_mutable_eltwise_param() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.eltwise_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::EltwiseParameter>(GetArenaForAllocation());
    _impl_.eltwise_param_ = p;
  }
  return _impl_.eltwise_param_;
}
inline ::opencv_caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() {
  ::opencv_caffe::EltwiseParameter* _msg = _internal_mutable_eltwise_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.eltwise_param)
  return _msg;
}
inline void LayerParameter::set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.eltwise_param_;
  }
  if (eltwise_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(eltwise_param);
    if (message_arena != submessage_arena) {
      eltwise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, eltwise_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.eltwise_param_ = eltwise_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.eltwise_param)
}

// optional .opencv_caffe.ELUParameter elu_param = 140;
inline bool LayerParameter::_internal_has_elu_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.elu_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_elu_param() const {
  return _internal_has_elu_param();
}
inline void LayerParameter::clear_elu_param() {
  if (_impl_.elu_param_ != nullptr) _impl_.elu_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline const ::opencv_caffe::ELUParameter& LayerParameter::_internal_elu_param() const {
  const ::opencv_caffe::ELUParameter* p = _impl_.elu_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ELUParameter&>(
      ::opencv_caffe::_ELUParameter_default_instance_);
}
inline const ::opencv_caffe::ELUParameter& LayerParameter::elu_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.elu_param)
  return _internal_elu_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_elu_param(
    ::opencv_caffe::ELUParameter* elu_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.elu_param_);
  }
  _impl_.elu_param_ = elu_param;
  if (elu_param) {
    _impl_._has_bits_[1] |= 0x00000400u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.elu_param)
}
inline ::opencv_caffe::ELUParameter* LayerParameter::release_elu_param() {
  _impl_._has_bits_[1] &= ~0x00000400u;
  ::opencv_caffe::ELUParameter* temp = _impl_.elu_param_;
  _impl_.elu_param_ = 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 ::opencv_caffe::ELUParameter* LayerParameter::unsafe_arena_release_elu_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.elu_param)
  _impl_._has_bits_[1] &= ~0x00000400u;
  ::opencv_caffe::ELUParameter* temp = _impl_.elu_param_;
  _impl_.elu_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ELUParameter* LayerParameter::_internal_mutable_elu_param() {
  _impl_._has_bits_[1] |= 0x00000400u;
  if (_impl_.elu_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ELUParameter>(GetArenaForAllocation());
    _impl_.elu_param_ = p;
  }
  return _impl_.elu_param_;
}
inline ::opencv_caffe::ELUParameter* LayerParameter::mutable_elu_param() {
  ::opencv_caffe::ELUParameter* _msg = _internal_mutable_elu_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.elu_param)
  return _msg;
}
inline void LayerParameter::set_allocated_elu_param(::opencv_caffe::ELUParameter* elu_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.elu_param_;
  }
  if (elu_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(elu_param);
    if (message_arena != submessage_arena) {
      elu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, elu_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000400u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000400u;
  }
  _impl_.elu_param_ = elu_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.elu_param)
}

// optional .opencv_caffe.EmbedParameter embed_param = 137;
inline bool LayerParameter::_internal_has_embed_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.embed_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_embed_param() const {
  return _internal_has_embed_param();
}
inline void LayerParameter::clear_embed_param() {
  if (_impl_.embed_param_ != nullptr) _impl_.embed_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline const ::opencv_caffe::EmbedParameter& LayerParameter::_internal_embed_param() const {
  const ::opencv_caffe::EmbedParameter* p = _impl_.embed_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::EmbedParameter&>(
      ::opencv_caffe::_EmbedParameter_default_instance_);
}
inline const ::opencv_caffe::EmbedParameter& LayerParameter::embed_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.embed_param)
  return _internal_embed_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_embed_param(
    ::opencv_caffe::EmbedParameter* embed_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.embed_param_);
  }
  _impl_.embed_param_ = embed_param;
  if (embed_param) {
    _impl_._has_bits_[1] |= 0x00000080u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.embed_param)
}
inline ::opencv_caffe::EmbedParameter* LayerParameter::release_embed_param() {
  _impl_._has_bits_[1] &= ~0x00000080u;
  ::opencv_caffe::EmbedParameter* temp = _impl_.embed_param_;
  _impl_.embed_param_ = 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 ::opencv_caffe::EmbedParameter* LayerParameter::unsafe_arena_release_embed_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.embed_param)
  _impl_._has_bits_[1] &= ~0x00000080u;
  ::opencv_caffe::EmbedParameter* temp = _impl_.embed_param_;
  _impl_.embed_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::EmbedParameter* LayerParameter::_internal_mutable_embed_param() {
  _impl_._has_bits_[1] |= 0x00000080u;
  if (_impl_.embed_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::EmbedParameter>(GetArenaForAllocation());
    _impl_.embed_param_ = p;
  }
  return _impl_.embed_param_;
}
inline ::opencv_caffe::EmbedParameter* LayerParameter::mutable_embed_param() {
  ::opencv_caffe::EmbedParameter* _msg = _internal_mutable_embed_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.embed_param)
  return _msg;
}
inline void LayerParameter::set_allocated_embed_param(::opencv_caffe::EmbedParameter* embed_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.embed_param_;
  }
  if (embed_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(embed_param);
    if (message_arena != submessage_arena) {
      embed_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, embed_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000080u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000080u;
  }
  _impl_.embed_param_ = embed_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.embed_param)
}

// optional .opencv_caffe.ExpParameter exp_param = 111;
inline bool LayerParameter::_internal_has_exp_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.exp_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_exp_param() const {
  return _internal_has_exp_param();
}
inline void LayerParameter::clear_exp_param() {
  if (_impl_.exp_param_ != nullptr) _impl_.exp_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::opencv_caffe::ExpParameter& LayerParameter::_internal_exp_param() const {
  const ::opencv_caffe::ExpParameter* p = _impl_.exp_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ExpParameter&>(
      ::opencv_caffe::_ExpParameter_default_instance_);
}
inline const ::opencv_caffe::ExpParameter& LayerParameter::exp_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.exp_param)
  return _internal_exp_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_exp_param(
    ::opencv_caffe::ExpParameter* exp_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exp_param_);
  }
  _impl_.exp_param_ = exp_param;
  if (exp_param) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.exp_param)
}
inline ::opencv_caffe::ExpParameter* LayerParameter::release_exp_param() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::opencv_caffe::ExpParameter* temp = _impl_.exp_param_;
  _impl_.exp_param_ = 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 ::opencv_caffe::ExpParameter* LayerParameter::unsafe_arena_release_exp_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.exp_param)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::opencv_caffe::ExpParameter* temp = _impl_.exp_param_;
  _impl_.exp_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ExpParameter* LayerParameter::_internal_mutable_exp_param() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.exp_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ExpParameter>(GetArenaForAllocation());
    _impl_.exp_param_ = p;
  }
  return _impl_.exp_param_;
}
inline ::opencv_caffe::ExpParameter* LayerParameter::mutable_exp_param() {
  ::opencv_caffe::ExpParameter* _msg = _internal_mutable_exp_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.exp_param)
  return _msg;
}
inline void LayerParameter::set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.exp_param_;
  }
  if (exp_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exp_param);
    if (message_arena != submessage_arena) {
      exp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, exp_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.exp_param_ = exp_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.exp_param)
}

// optional .opencv_caffe.FlattenParameter flatten_param = 135;
inline bool LayerParameter::_internal_has_flatten_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.flatten_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_flatten_param() const {
  return _internal_has_flatten_param();
}
inline void LayerParameter::clear_flatten_param() {
  if (_impl_.flatten_param_ != nullptr) _impl_.flatten_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline const ::opencv_caffe::FlattenParameter& LayerParameter::_internal_flatten_param() const {
  const ::opencv_caffe::FlattenParameter* p = _impl_.flatten_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FlattenParameter&>(
      ::opencv_caffe::_FlattenParameter_default_instance_);
}
inline const ::opencv_caffe::FlattenParameter& LayerParameter::flatten_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.flatten_param)
  return _internal_flatten_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_flatten_param(
    ::opencv_caffe::FlattenParameter* flatten_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.flatten_param_);
  }
  _impl_.flatten_param_ = flatten_param;
  if (flatten_param) {
    _impl_._has_bits_[1] |= 0x00000020u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.flatten_param)
}
inline ::opencv_caffe::FlattenParameter* LayerParameter::release_flatten_param() {
  _impl_._has_bits_[1] &= ~0x00000020u;
  ::opencv_caffe::FlattenParameter* temp = _impl_.flatten_param_;
  _impl_.flatten_param_ = 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 ::opencv_caffe::FlattenParameter* LayerParameter::unsafe_arena_release_flatten_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.flatten_param)
  _impl_._has_bits_[1] &= ~0x00000020u;
  ::opencv_caffe::FlattenParameter* temp = _impl_.flatten_param_;
  _impl_.flatten_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FlattenParameter* LayerParameter::_internal_mutable_flatten_param() {
  _impl_._has_bits_[1] |= 0x00000020u;
  if (_impl_.flatten_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FlattenParameter>(GetArenaForAllocation());
    _impl_.flatten_param_ = p;
  }
  return _impl_.flatten_param_;
}
inline ::opencv_caffe::FlattenParameter* LayerParameter::mutable_flatten_param() {
  ::opencv_caffe::FlattenParameter* _msg = _internal_mutable_flatten_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.flatten_param)
  return _msg;
}
inline void LayerParameter::set_allocated_flatten_param(::opencv_caffe::FlattenParameter* flatten_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.flatten_param_;
  }
  if (flatten_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(flatten_param);
    if (message_arena != submessage_arena) {
      flatten_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flatten_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000020u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000020u;
  }
  _impl_.flatten_param_ = flatten_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.flatten_param)
}

// optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
inline bool LayerParameter::_internal_has_hdf5_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hdf5_data_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_hdf5_data_param() const {
  return _internal_has_hdf5_data_param();
}
inline void LayerParameter::clear_hdf5_data_param() {
  if (_impl_.hdf5_data_param_ != nullptr) _impl_.hdf5_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::opencv_caffe::HDF5DataParameter& LayerParameter::_internal_hdf5_data_param() const {
  const ::opencv_caffe::HDF5DataParameter* p = _impl_.hdf5_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HDF5DataParameter&>(
      ::opencv_caffe::_HDF5DataParameter_default_instance_);
}
inline const ::opencv_caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hdf5_data_param)
  return _internal_hdf5_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_hdf5_data_param(
    ::opencv_caffe::HDF5DataParameter* hdf5_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hdf5_data_param_);
  }
  _impl_.hdf5_data_param_ = hdf5_data_param;
  if (hdf5_data_param) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.hdf5_data_param)
}
inline ::opencv_caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::opencv_caffe::HDF5DataParameter* temp = _impl_.hdf5_data_param_;
  _impl_.hdf5_data_param_ = 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 ::opencv_caffe::HDF5DataParameter* LayerParameter::unsafe_arena_release_hdf5_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hdf5_data_param)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::opencv_caffe::HDF5DataParameter* temp = _impl_.hdf5_data_param_;
  _impl_.hdf5_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HDF5DataParameter* LayerParameter::_internal_mutable_hdf5_data_param() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.hdf5_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HDF5DataParameter>(GetArenaForAllocation());
    _impl_.hdf5_data_param_ = p;
  }
  return _impl_.hdf5_data_param_;
}
inline ::opencv_caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() {
  ::opencv_caffe::HDF5DataParameter* _msg = _internal_mutable_hdf5_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hdf5_data_param)
  return _msg;
}
inline void LayerParameter::set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hdf5_data_param_;
  }
  if (hdf5_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hdf5_data_param);
    if (message_arena != submessage_arena) {
      hdf5_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hdf5_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.hdf5_data_param_ = hdf5_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.hdf5_data_param)
}

// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
inline bool LayerParameter::_internal_has_hdf5_output_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hdf5_output_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_hdf5_output_param() const {
  return _internal_has_hdf5_output_param();
}
inline void LayerParameter::clear_hdf5_output_param() {
  if (_impl_.hdf5_output_param_ != nullptr) _impl_.hdf5_output_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::opencv_caffe::HDF5OutputParameter& LayerParameter::_internal_hdf5_output_param() const {
  const ::opencv_caffe::HDF5OutputParameter* p = _impl_.hdf5_output_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HDF5OutputParameter&>(
      ::opencv_caffe::_HDF5OutputParameter_default_instance_);
}
inline const ::opencv_caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hdf5_output_param)
  return _internal_hdf5_output_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_hdf5_output_param(
    ::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hdf5_output_param_);
  }
  _impl_.hdf5_output_param_ = hdf5_output_param;
  if (hdf5_output_param) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.hdf5_output_param)
}
inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::opencv_caffe::HDF5OutputParameter* temp = _impl_.hdf5_output_param_;
  _impl_.hdf5_output_param_ = 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 ::opencv_caffe::HDF5OutputParameter* LayerParameter::unsafe_arena_release_hdf5_output_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hdf5_output_param)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::opencv_caffe::HDF5OutputParameter* temp = _impl_.hdf5_output_param_;
  _impl_.hdf5_output_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::_internal_mutable_hdf5_output_param() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.hdf5_output_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(GetArenaForAllocation());
    _impl_.hdf5_output_param_ = p;
  }
  return _impl_.hdf5_output_param_;
}
inline ::opencv_caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() {
  ::opencv_caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hdf5_output_param)
  return _msg;
}
inline void LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hdf5_output_param_;
  }
  if (hdf5_output_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hdf5_output_param);
    if (message_arena != submessage_arena) {
      hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hdf5_output_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.hdf5_output_param_ = hdf5_output_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.hdf5_output_param)
}

// optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
inline bool LayerParameter::_internal_has_hinge_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hinge_loss_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_hinge_loss_param() const {
  return _internal_has_hinge_loss_param();
}
inline void LayerParameter::clear_hinge_loss_param() {
  if (_impl_.hinge_loss_param_ != nullptr) _impl_.hinge_loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::opencv_caffe::HingeLossParameter& LayerParameter::_internal_hinge_loss_param() const {
  const ::opencv_caffe::HingeLossParameter* p = _impl_.hinge_loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HingeLossParameter&>(
      ::opencv_caffe::_HingeLossParameter_default_instance_);
}
inline const ::opencv_caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.hinge_loss_param)
  return _internal_hinge_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_hinge_loss_param(
    ::opencv_caffe::HingeLossParameter* hinge_loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hinge_loss_param_);
  }
  _impl_.hinge_loss_param_ = hinge_loss_param;
  if (hinge_loss_param) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.hinge_loss_param)
}
inline ::opencv_caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::opencv_caffe::HingeLossParameter* temp = _impl_.hinge_loss_param_;
  _impl_.hinge_loss_param_ = 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 ::opencv_caffe::HingeLossParameter* LayerParameter::unsafe_arena_release_hinge_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.hinge_loss_param)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::opencv_caffe::HingeLossParameter* temp = _impl_.hinge_loss_param_;
  _impl_.hinge_loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HingeLossParameter* LayerParameter::_internal_mutable_hinge_loss_param() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.hinge_loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HingeLossParameter>(GetArenaForAllocation());
    _impl_.hinge_loss_param_ = p;
  }
  return _impl_.hinge_loss_param_;
}
inline ::opencv_caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() {
  ::opencv_caffe::HingeLossParameter* _msg = _internal_mutable_hinge_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.hinge_loss_param)
  return _msg;
}
inline void LayerParameter::set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hinge_loss_param_;
  }
  if (hinge_loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hinge_loss_param);
    if (message_arena != submessage_arena) {
      hinge_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hinge_loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.hinge_loss_param_ = hinge_loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.hinge_loss_param)
}

// optional .opencv_caffe.ImageDataParameter image_data_param = 115;
inline bool LayerParameter::_internal_has_image_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.image_data_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_image_data_param() const {
  return _internal_has_image_data_param();
}
inline void LayerParameter::clear_image_data_param() {
  if (_impl_.image_data_param_ != nullptr) _impl_.image_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const ::opencv_caffe::ImageDataParameter& LayerParameter::_internal_image_data_param() const {
  const ::opencv_caffe::ImageDataParameter* p = _impl_.image_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ImageDataParameter&>(
      ::opencv_caffe::_ImageDataParameter_default_instance_);
}
inline const ::opencv_caffe::ImageDataParameter& LayerParameter::image_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.image_data_param)
  return _internal_image_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_image_data_param(
    ::opencv_caffe::ImageDataParameter* image_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_data_param_);
  }
  _impl_.image_data_param_ = image_data_param;
  if (image_data_param) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.image_data_param)
}
inline ::opencv_caffe::ImageDataParameter* LayerParameter::release_image_data_param() {
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::opencv_caffe::ImageDataParameter* temp = _impl_.image_data_param_;
  _impl_.image_data_param_ = 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 ::opencv_caffe::ImageDataParameter* LayerParameter::unsafe_arena_release_image_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.image_data_param)
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::opencv_caffe::ImageDataParameter* temp = _impl_.image_data_param_;
  _impl_.image_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ImageDataParameter* LayerParameter::_internal_mutable_image_data_param() {
  _impl_._has_bits_[0] |= 0x00020000u;
  if (_impl_.image_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ImageDataParameter>(GetArenaForAllocation());
    _impl_.image_data_param_ = p;
  }
  return _impl_.image_data_param_;
}
inline ::opencv_caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() {
  ::opencv_caffe::ImageDataParameter* _msg = _internal_mutable_image_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.image_data_param)
  return _msg;
}
inline void LayerParameter::set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.image_data_param_;
  }
  if (image_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_data_param);
    if (message_arena != submessage_arena) {
      image_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, image_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.image_data_param_ = image_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.image_data_param)
}

// optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
inline bool LayerParameter::_internal_has_infogain_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.infogain_loss_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_infogain_loss_param() const {
  return _internal_has_infogain_loss_param();
}
inline void LayerParameter::clear_infogain_loss_param() {
  if (_impl_.infogain_loss_param_ != nullptr) _impl_.infogain_loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const ::opencv_caffe::InfogainLossParameter& LayerParameter::_internal_infogain_loss_param() const {
  const ::opencv_caffe::InfogainLossParameter* p = _impl_.infogain_loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::InfogainLossParameter&>(
      ::opencv_caffe::_InfogainLossParameter_default_instance_);
}
inline const ::opencv_caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.infogain_loss_param)
  return _internal_infogain_loss_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_infogain_loss_param(
    ::opencv_caffe::InfogainLossParameter* infogain_loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.infogain_loss_param_);
  }
  _impl_.infogain_loss_param_ = infogain_loss_param;
  if (infogain_loss_param) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.infogain_loss_param)
}
inline ::opencv_caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() {
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::opencv_caffe::InfogainLossParameter* temp = _impl_.infogain_loss_param_;
  _impl_.infogain_loss_param_ = 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 ::opencv_caffe::InfogainLossParameter* LayerParameter::unsafe_arena_release_infogain_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.infogain_loss_param)
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::opencv_caffe::InfogainLossParameter* temp = _impl_.infogain_loss_param_;
  _impl_.infogain_loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::InfogainLossParameter* LayerParameter::_internal_mutable_infogain_loss_param() {
  _impl_._has_bits_[0] |= 0x00040000u;
  if (_impl_.infogain_loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::InfogainLossParameter>(GetArenaForAllocation());
    _impl_.infogain_loss_param_ = p;
  }
  return _impl_.infogain_loss_param_;
}
inline ::opencv_caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() {
  ::opencv_caffe::InfogainLossParameter* _msg = _internal_mutable_infogain_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.infogain_loss_param)
  return _msg;
}
inline void LayerParameter::set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.infogain_loss_param_;
  }
  if (infogain_loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(infogain_loss_param);
    if (message_arena != submessage_arena) {
      infogain_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, infogain_loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.infogain_loss_param_ = infogain_loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.infogain_loss_param)
}

// optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
inline bool LayerParameter::_internal_has_inner_product_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.inner_product_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_inner_product_param() const {
  return _internal_has_inner_product_param();
}
inline void LayerParameter::clear_inner_product_param() {
  if (_impl_.inner_product_param_ != nullptr) _impl_.inner_product_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline const ::opencv_caffe::InnerProductParameter& LayerParameter::_internal_inner_product_param() const {
  const ::opencv_caffe::InnerProductParameter* p = _impl_.inner_product_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::InnerProductParameter&>(
      ::opencv_caffe::_InnerProductParameter_default_instance_);
}
inline const ::opencv_caffe::InnerProductParameter& LayerParameter::inner_product_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.inner_product_param)
  return _internal_inner_product_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_inner_product_param(
    ::opencv_caffe::InnerProductParameter* inner_product_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.inner_product_param_);
  }
  _impl_.inner_product_param_ = inner_product_param;
  if (inner_product_param) {
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.inner_product_param)
}
inline ::opencv_caffe::InnerProductParameter* LayerParameter::release_inner_product_param() {
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::opencv_caffe::InnerProductParameter* temp = _impl_.inner_product_param_;
  _impl_.inner_product_param_ = 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 ::opencv_caffe::InnerProductParameter* LayerParameter::unsafe_arena_release_inner_product_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.inner_product_param)
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::opencv_caffe::InnerProductParameter* temp = _impl_.inner_product_param_;
  _impl_.inner_product_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::InnerProductParameter* LayerParameter::_internal_mutable_inner_product_param() {
  _impl_._has_bits_[0] |= 0x00080000u;
  if (_impl_.inner_product_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::InnerProductParameter>(GetArenaForAllocation());
    _impl_.inner_product_param_ = p;
  }
  return _impl_.inner_product_param_;
}
inline ::opencv_caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() {
  ::opencv_caffe::InnerProductParameter* _msg = _internal_mutable_inner_product_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.inner_product_param)
  return _msg;
}
inline void LayerParameter::set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.inner_product_param_;
  }
  if (inner_product_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(inner_product_param);
    if (message_arena != submessage_arena) {
      inner_product_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, inner_product_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  _impl_.inner_product_param_ = inner_product_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.inner_product_param)
}

// optional .opencv_caffe.InputParameter input_param = 143;
inline bool LayerParameter::_internal_has_input_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.input_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_input_param() const {
  return _internal_has_input_param();
}
inline void LayerParameter::clear_input_param() {
  if (_impl_.input_param_ != nullptr) _impl_.input_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00002000u;
}
inline const ::opencv_caffe::InputParameter& LayerParameter::_internal_input_param() const {
  const ::opencv_caffe::InputParameter* p = _impl_.input_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::InputParameter&>(
      ::opencv_caffe::_InputParameter_default_instance_);
}
inline const ::opencv_caffe::InputParameter& LayerParameter::input_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.input_param)
  return _internal_input_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_input_param(
    ::opencv_caffe::InputParameter* input_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.input_param_);
  }
  _impl_.input_param_ = input_param;
  if (input_param) {
    _impl_._has_bits_[1] |= 0x00002000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.input_param)
}
inline ::opencv_caffe::InputParameter* LayerParameter::release_input_param() {
  _impl_._has_bits_[1] &= ~0x00002000u;
  ::opencv_caffe::InputParameter* temp = _impl_.input_param_;
  _impl_.input_param_ = 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 ::opencv_caffe::InputParameter* LayerParameter::unsafe_arena_release_input_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.input_param)
  _impl_._has_bits_[1] &= ~0x00002000u;
  ::opencv_caffe::InputParameter* temp = _impl_.input_param_;
  _impl_.input_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::InputParameter* LayerParameter::_internal_mutable_input_param() {
  _impl_._has_bits_[1] |= 0x00002000u;
  if (_impl_.input_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::InputParameter>(GetArenaForAllocation());
    _impl_.input_param_ = p;
  }
  return _impl_.input_param_;
}
inline ::opencv_caffe::InputParameter* LayerParameter::mutable_input_param() {
  ::opencv_caffe::InputParameter* _msg = _internal_mutable_input_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.input_param)
  return _msg;
}
inline void LayerParameter::set_allocated_input_param(::opencv_caffe::InputParameter* input_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.input_param_;
  }
  if (input_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(input_param);
    if (message_arena != submessage_arena) {
      input_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, input_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00002000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00002000u;
  }
  _impl_.input_param_ = input_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.input_param)
}

// optional .opencv_caffe.LogParameter log_param = 134;
inline bool LayerParameter::_internal_has_log_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.log_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_log_param() const {
  return _internal_has_log_param();
}
inline void LayerParameter::clear_log_param() {
  if (_impl_.log_param_ != nullptr) _impl_.log_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline const ::opencv_caffe::LogParameter& LayerParameter::_internal_log_param() const {
  const ::opencv_caffe::LogParameter* p = _impl_.log_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::LogParameter&>(
      ::opencv_caffe::_LogParameter_default_instance_);
}
inline const ::opencv_caffe::LogParameter& LayerParameter::log_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.log_param)
  return _internal_log_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_log_param(
    ::opencv_caffe::LogParameter* log_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.log_param_);
  }
  _impl_.log_param_ = log_param;
  if (log_param) {
    _impl_._has_bits_[1] |= 0x00000010u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.log_param)
}
inline ::opencv_caffe::LogParameter* LayerParameter::release_log_param() {
  _impl_._has_bits_[1] &= ~0x00000010u;
  ::opencv_caffe::LogParameter* temp = _impl_.log_param_;
  _impl_.log_param_ = 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 ::opencv_caffe::LogParameter* LayerParameter::unsafe_arena_release_log_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.log_param)
  _impl_._has_bits_[1] &= ~0x00000010u;
  ::opencv_caffe::LogParameter* temp = _impl_.log_param_;
  _impl_.log_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::LogParameter* LayerParameter::_internal_mutable_log_param() {
  _impl_._has_bits_[1] |= 0x00000010u;
  if (_impl_.log_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::LogParameter>(GetArenaForAllocation());
    _impl_.log_param_ = p;
  }
  return _impl_.log_param_;
}
inline ::opencv_caffe::LogParameter* LayerParameter::mutable_log_param() {
  ::opencv_caffe::LogParameter* _msg = _internal_mutable_log_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.log_param)
  return _msg;
}
inline void LayerParameter::set_allocated_log_param(::opencv_caffe::LogParameter* log_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.log_param_;
  }
  if (log_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(log_param);
    if (message_arena != submessage_arena) {
      log_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, log_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000010u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000010u;
  }
  _impl_.log_param_ = log_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.log_param)
}

// optional .opencv_caffe.LRNParameter lrn_param = 118;
inline bool LayerParameter::_internal_has_lrn_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lrn_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_lrn_param() const {
  return _internal_has_lrn_param();
}
inline void LayerParameter::clear_lrn_param() {
  if (_impl_.lrn_param_ != nullptr) _impl_.lrn_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline const ::opencv_caffe::LRNParameter& LayerParameter::_internal_lrn_param() const {
  const ::opencv_caffe::LRNParameter* p = _impl_.lrn_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::LRNParameter&>(
      ::opencv_caffe::_LRNParameter_default_instance_);
}
inline const ::opencv_caffe::LRNParameter& LayerParameter::lrn_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.lrn_param)
  return _internal_lrn_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_lrn_param(
    ::opencv_caffe::LRNParameter* lrn_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lrn_param_);
  }
  _impl_.lrn_param_ = lrn_param;
  if (lrn_param) {
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.lrn_param)
}
inline ::opencv_caffe::LRNParameter* LayerParameter::release_lrn_param() {
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::opencv_caffe::LRNParameter* temp = _impl_.lrn_param_;
  _impl_.lrn_param_ = 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 ::opencv_caffe::LRNParameter* LayerParameter::unsafe_arena_release_lrn_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.lrn_param)
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::opencv_caffe::LRNParameter* temp = _impl_.lrn_param_;
  _impl_.lrn_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::LRNParameter* LayerParameter::_internal_mutable_lrn_param() {
  _impl_._has_bits_[0] |= 0x00100000u;
  if (_impl_.lrn_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::LRNParameter>(GetArenaForAllocation());
    _impl_.lrn_param_ = p;
  }
  return _impl_.lrn_param_;
}
inline ::opencv_caffe::LRNParameter* LayerParameter::mutable_lrn_param() {
  ::opencv_caffe::LRNParameter* _msg = _internal_mutable_lrn_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.lrn_param)
  return _msg;
}
inline void LayerParameter::set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lrn_param_;
  }
  if (lrn_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lrn_param);
    if (message_arena != submessage_arena) {
      lrn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lrn_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  _impl_.lrn_param_ = lrn_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.lrn_param)
}

// optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
inline bool LayerParameter::_internal_has_memory_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.memory_data_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_memory_data_param() const {
  return _internal_has_memory_data_param();
}
inline void LayerParameter::clear_memory_data_param() {
  if (_impl_.memory_data_param_ != nullptr) _impl_.memory_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline const ::opencv_caffe::MemoryDataParameter& LayerParameter::_internal_memory_data_param() const {
  const ::opencv_caffe::MemoryDataParameter* p = _impl_.memory_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::MemoryDataParameter&>(
      ::opencv_caffe::_MemoryDataParameter_default_instance_);
}
inline const ::opencv_caffe::MemoryDataParameter& LayerParameter::memory_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.memory_data_param)
  return _internal_memory_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_memory_data_param(
    ::opencv_caffe::MemoryDataParameter* memory_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memory_data_param_);
  }
  _impl_.memory_data_param_ = memory_data_param;
  if (memory_data_param) {
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.memory_data_param)
}
inline ::opencv_caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() {
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::opencv_caffe::MemoryDataParameter* temp = _impl_.memory_data_param_;
  _impl_.memory_data_param_ = 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 ::opencv_caffe::MemoryDataParameter* LayerParameter::unsafe_arena_release_memory_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.memory_data_param)
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::opencv_caffe::MemoryDataParameter* temp = _impl_.memory_data_param_;
  _impl_.memory_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::MemoryDataParameter* LayerParameter::_internal_mutable_memory_data_param() {
  _impl_._has_bits_[0] |= 0x00200000u;
  if (_impl_.memory_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::MemoryDataParameter>(GetArenaForAllocation());
    _impl_.memory_data_param_ = p;
  }
  return _impl_.memory_data_param_;
}
inline ::opencv_caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() {
  ::opencv_caffe::MemoryDataParameter* _msg = _internal_mutable_memory_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.memory_data_param)
  return _msg;
}
inline void LayerParameter::set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memory_data_param_;
  }
  if (memory_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memory_data_param);
    if (message_arena != submessage_arena) {
      memory_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memory_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  _impl_.memory_data_param_ = memory_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.memory_data_param)
}

// optional .opencv_caffe.MVNParameter mvn_param = 120;
inline bool LayerParameter::_internal_has_mvn_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mvn_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_mvn_param() const {
  return _internal_has_mvn_param();
}
inline void LayerParameter::clear_mvn_param() {
  if (_impl_.mvn_param_ != nullptr) _impl_.mvn_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline const ::opencv_caffe::MVNParameter& LayerParameter::_internal_mvn_param() const {
  const ::opencv_caffe::MVNParameter* p = _impl_.mvn_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::MVNParameter&>(
      ::opencv_caffe::_MVNParameter_default_instance_);
}
inline const ::opencv_caffe::MVNParameter& LayerParameter::mvn_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.mvn_param)
  return _internal_mvn_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_mvn_param(
    ::opencv_caffe::MVNParameter* mvn_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mvn_param_);
  }
  _impl_.mvn_param_ = mvn_param;
  if (mvn_param) {
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.mvn_param)
}
inline ::opencv_caffe::MVNParameter* LayerParameter::release_mvn_param() {
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::opencv_caffe::MVNParameter* temp = _impl_.mvn_param_;
  _impl_.mvn_param_ = 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 ::opencv_caffe::MVNParameter* LayerParameter::unsafe_arena_release_mvn_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.mvn_param)
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::opencv_caffe::MVNParameter* temp = _impl_.mvn_param_;
  _impl_.mvn_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::MVNParameter* LayerParameter::_internal_mutable_mvn_param() {
  _impl_._has_bits_[0] |= 0x00400000u;
  if (_impl_.mvn_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::MVNParameter>(GetArenaForAllocation());
    _impl_.mvn_param_ = p;
  }
  return _impl_.mvn_param_;
}
inline ::opencv_caffe::MVNParameter* LayerParameter::mutable_mvn_param() {
  ::opencv_caffe::MVNParameter* _msg = _internal_mutable_mvn_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.mvn_param)
  return _msg;
}
inline void LayerParameter::set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.mvn_param_;
  }
  if (mvn_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mvn_param);
    if (message_arena != submessage_arena) {
      mvn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mvn_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  _impl_.mvn_param_ = mvn_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.mvn_param)
}

// optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
inline bool LayerParameter::_internal_has_norm_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00080000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.norm_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_norm_param() const {
  return _internal_has_norm_param();
}
inline void LayerParameter::clear_norm_param() {
  if (_impl_.norm_param_ != nullptr) _impl_.norm_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00080000u;
}
inline const ::opencv_caffe::NormalizeBBoxParameter& LayerParameter::_internal_norm_param() const {
  const ::opencv_caffe::NormalizeBBoxParameter* p = _impl_.norm_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::NormalizeBBoxParameter&>(
      ::opencv_caffe::_NormalizeBBoxParameter_default_instance_);
}
inline const ::opencv_caffe::NormalizeBBoxParameter& LayerParameter::norm_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.norm_param)
  return _internal_norm_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_norm_param(
    ::opencv_caffe::NormalizeBBoxParameter* norm_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.norm_param_);
  }
  _impl_.norm_param_ = norm_param;
  if (norm_param) {
    _impl_._has_bits_[1] |= 0x00080000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00080000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.norm_param)
}
inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::release_norm_param() {
  _impl_._has_bits_[1] &= ~0x00080000u;
  ::opencv_caffe::NormalizeBBoxParameter* temp = _impl_.norm_param_;
  _impl_.norm_param_ = 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 ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::unsafe_arena_release_norm_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.norm_param)
  _impl_._has_bits_[1] &= ~0x00080000u;
  ::opencv_caffe::NormalizeBBoxParameter* temp = _impl_.norm_param_;
  _impl_.norm_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::_internal_mutable_norm_param() {
  _impl_._has_bits_[1] |= 0x00080000u;
  if (_impl_.norm_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::NormalizeBBoxParameter>(GetArenaForAllocation());
    _impl_.norm_param_ = p;
  }
  return _impl_.norm_param_;
}
inline ::opencv_caffe::NormalizeBBoxParameter* LayerParameter::mutable_norm_param() {
  ::opencv_caffe::NormalizeBBoxParameter* _msg = _internal_mutable_norm_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.norm_param)
  return _msg;
}
inline void LayerParameter::set_allocated_norm_param(::opencv_caffe::NormalizeBBoxParameter* norm_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.norm_param_;
  }
  if (norm_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(norm_param);
    if (message_arena != submessage_arena) {
      norm_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, norm_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00080000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00080000u;
  }
  _impl_.norm_param_ = norm_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.norm_param)
}

// optional .opencv_caffe.PermuteParameter permute_param = 148;
inline bool LayerParameter::_internal_has_permute_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.permute_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_permute_param() const {
  return _internal_has_permute_param();
}
inline void LayerParameter::clear_permute_param() {
  if (_impl_.permute_param_ != nullptr) _impl_.permute_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00040000u;
}
inline const ::opencv_caffe::PermuteParameter& LayerParameter::_internal_permute_param() const {
  const ::opencv_caffe::PermuteParameter* p = _impl_.permute_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PermuteParameter&>(
      ::opencv_caffe::_PermuteParameter_default_instance_);
}
inline const ::opencv_caffe::PermuteParameter& LayerParameter::permute_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.permute_param)
  return _internal_permute_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_permute_param(
    ::opencv_caffe::PermuteParameter* permute_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.permute_param_);
  }
  _impl_.permute_param_ = permute_param;
  if (permute_param) {
    _impl_._has_bits_[1] |= 0x00040000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.permute_param)
}
inline ::opencv_caffe::PermuteParameter* LayerParameter::release_permute_param() {
  _impl_._has_bits_[1] &= ~0x00040000u;
  ::opencv_caffe::PermuteParameter* temp = _impl_.permute_param_;
  _impl_.permute_param_ = 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 ::opencv_caffe::PermuteParameter* LayerParameter::unsafe_arena_release_permute_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.permute_param)
  _impl_._has_bits_[1] &= ~0x00040000u;
  ::opencv_caffe::PermuteParameter* temp = _impl_.permute_param_;
  _impl_.permute_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PermuteParameter* LayerParameter::_internal_mutable_permute_param() {
  _impl_._has_bits_[1] |= 0x00040000u;
  if (_impl_.permute_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PermuteParameter>(GetArenaForAllocation());
    _impl_.permute_param_ = p;
  }
  return _impl_.permute_param_;
}
inline ::opencv_caffe::PermuteParameter* LayerParameter::mutable_permute_param() {
  ::opencv_caffe::PermuteParameter* _msg = _internal_mutable_permute_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.permute_param)
  return _msg;
}
inline void LayerParameter::set_allocated_permute_param(::opencv_caffe::PermuteParameter* permute_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.permute_param_;
  }
  if (permute_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(permute_param);
    if (message_arena != submessage_arena) {
      permute_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, permute_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00040000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00040000u;
  }
  _impl_.permute_param_ = permute_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.permute_param)
}

// optional .opencv_caffe.ParameterParameter parameter_param = 145;
inline bool LayerParameter::_internal_has_parameter_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.parameter_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_parameter_param() const {
  return _internal_has_parameter_param();
}
inline void LayerParameter::clear_parameter_param() {
  if (_impl_.parameter_param_ != nullptr) _impl_.parameter_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00008000u;
}
inline const ::opencv_caffe::ParameterParameter& LayerParameter::_internal_parameter_param() const {
  const ::opencv_caffe::ParameterParameter* p = _impl_.parameter_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ParameterParameter&>(
      ::opencv_caffe::_ParameterParameter_default_instance_);
}
inline const ::opencv_caffe::ParameterParameter& LayerParameter::parameter_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.parameter_param)
  return _internal_parameter_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_parameter_param(
    ::opencv_caffe::ParameterParameter* parameter_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.parameter_param_);
  }
  _impl_.parameter_param_ = parameter_param;
  if (parameter_param) {
    _impl_._has_bits_[1] |= 0x00008000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.parameter_param)
}
inline ::opencv_caffe::ParameterParameter* LayerParameter::release_parameter_param() {
  _impl_._has_bits_[1] &= ~0x00008000u;
  ::opencv_caffe::ParameterParameter* temp = _impl_.parameter_param_;
  _impl_.parameter_param_ = 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 ::opencv_caffe::ParameterParameter* LayerParameter::unsafe_arena_release_parameter_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.parameter_param)
  _impl_._has_bits_[1] &= ~0x00008000u;
  ::opencv_caffe::ParameterParameter* temp = _impl_.parameter_param_;
  _impl_.parameter_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ParameterParameter* LayerParameter::_internal_mutable_parameter_param() {
  _impl_._has_bits_[1] |= 0x00008000u;
  if (_impl_.parameter_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ParameterParameter>(GetArenaForAllocation());
    _impl_.parameter_param_ = p;
  }
  return _impl_.parameter_param_;
}
inline ::opencv_caffe::ParameterParameter* LayerParameter::mutable_parameter_param() {
  ::opencv_caffe::ParameterParameter* _msg = _internal_mutable_parameter_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.parameter_param)
  return _msg;
}
inline void LayerParameter::set_allocated_parameter_param(::opencv_caffe::ParameterParameter* parameter_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.parameter_param_;
  }
  if (parameter_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(parameter_param);
    if (message_arena != submessage_arena) {
      parameter_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameter_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00008000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00008000u;
  }
  _impl_.parameter_param_ = parameter_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.parameter_param)
}

// optional .opencv_caffe.PoolingParameter pooling_param = 121;
inline bool LayerParameter::_internal_has_pooling_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pooling_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_pooling_param() const {
  return _internal_has_pooling_param();
}
inline void LayerParameter::clear_pooling_param() {
  if (_impl_.pooling_param_ != nullptr) _impl_.pooling_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline const ::opencv_caffe::PoolingParameter& LayerParameter::_internal_pooling_param() const {
  const ::opencv_caffe::PoolingParameter* p = _impl_.pooling_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PoolingParameter&>(
      ::opencv_caffe::_PoolingParameter_default_instance_);
}
inline const ::opencv_caffe::PoolingParameter& LayerParameter::pooling_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.pooling_param)
  return _internal_pooling_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_pooling_param(
    ::opencv_caffe::PoolingParameter* pooling_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pooling_param_);
  }
  _impl_.pooling_param_ = pooling_param;
  if (pooling_param) {
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.pooling_param)
}
inline ::opencv_caffe::PoolingParameter* LayerParameter::release_pooling_param() {
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::opencv_caffe::PoolingParameter* temp = _impl_.pooling_param_;
  _impl_.pooling_param_ = 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 ::opencv_caffe::PoolingParameter* LayerParameter::unsafe_arena_release_pooling_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.pooling_param)
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::opencv_caffe::PoolingParameter* temp = _impl_.pooling_param_;
  _impl_.pooling_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PoolingParameter* LayerParameter::_internal_mutable_pooling_param() {
  _impl_._has_bits_[0] |= 0x00800000u;
  if (_impl_.pooling_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PoolingParameter>(GetArenaForAllocation());
    _impl_.pooling_param_ = p;
  }
  return _impl_.pooling_param_;
}
inline ::opencv_caffe::PoolingParameter* LayerParameter::mutable_pooling_param() {
  ::opencv_caffe::PoolingParameter* _msg = _internal_mutable_pooling_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.pooling_param)
  return _msg;
}
inline void LayerParameter::set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pooling_param_;
  }
  if (pooling_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pooling_param);
    if (message_arena != submessage_arena) {
      pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pooling_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  _impl_.pooling_param_ = pooling_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.pooling_param)
}

// optional .opencv_caffe.PowerParameter power_param = 122;
inline bool LayerParameter::_internal_has_power_param() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.power_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_power_param() const {
  return _internal_has_power_param();
}
inline void LayerParameter::clear_power_param() {
  if (_impl_.power_param_ != nullptr) _impl_.power_param_->Clear();
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline const ::opencv_caffe::PowerParameter& LayerParameter::_internal_power_param() const {
  const ::opencv_caffe::PowerParameter* p = _impl_.power_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PowerParameter&>(
      ::opencv_caffe::_PowerParameter_default_instance_);
}
inline const ::opencv_caffe::PowerParameter& LayerParameter::power_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.power_param)
  return _internal_power_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_power_param(
    ::opencv_caffe::PowerParameter* power_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.power_param_);
  }
  _impl_.power_param_ = power_param;
  if (power_param) {
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.power_param)
}
inline ::opencv_caffe::PowerParameter* LayerParameter::release_power_param() {
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::opencv_caffe::PowerParameter* temp = _impl_.power_param_;
  _impl_.power_param_ = 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 ::opencv_caffe::PowerParameter* LayerParameter::unsafe_arena_release_power_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.power_param)
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::opencv_caffe::PowerParameter* temp = _impl_.power_param_;
  _impl_.power_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PowerParameter* LayerParameter::_internal_mutable_power_param() {
  _impl_._has_bits_[0] |= 0x01000000u;
  if (_impl_.power_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PowerParameter>(GetArenaForAllocation());
    _impl_.power_param_ = p;
  }
  return _impl_.power_param_;
}
inline ::opencv_caffe::PowerParameter* LayerParameter::mutable_power_param() {
  ::opencv_caffe::PowerParameter* _msg = _internal_mutable_power_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.power_param)
  return _msg;
}
inline void LayerParameter::set_allocated_power_param(::opencv_caffe::PowerParameter* power_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.power_param_;
  }
  if (power_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(power_param);
    if (message_arena != submessage_arena) {
      power_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, power_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  _impl_.power_param_ = power_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.power_param)
}

// optional .opencv_caffe.PReLUParameter prelu_param = 131;
inline bool LayerParameter::_internal_has_prelu_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.prelu_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_prelu_param() const {
  return _internal_has_prelu_param();
}
inline void LayerParameter::clear_prelu_param() {
  if (_impl_.prelu_param_ != nullptr) _impl_.prelu_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline const ::opencv_caffe::PReLUParameter& LayerParameter::_internal_prelu_param() const {
  const ::opencv_caffe::PReLUParameter* p = _impl_.prelu_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PReLUParameter&>(
      ::opencv_caffe::_PReLUParameter_default_instance_);
}
inline const ::opencv_caffe::PReLUParameter& LayerParameter::prelu_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.prelu_param)
  return _internal_prelu_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_prelu_param(
    ::opencv_caffe::PReLUParameter* prelu_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.prelu_param_);
  }
  _impl_.prelu_param_ = prelu_param;
  if (prelu_param) {
    _impl_._has_bits_[1] |= 0x00000002u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.prelu_param)
}
inline ::opencv_caffe::PReLUParameter* LayerParameter::release_prelu_param() {
  _impl_._has_bits_[1] &= ~0x00000002u;
  ::opencv_caffe::PReLUParameter* temp = _impl_.prelu_param_;
  _impl_.prelu_param_ = 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 ::opencv_caffe::PReLUParameter* LayerParameter::unsafe_arena_release_prelu_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.prelu_param)
  _impl_._has_bits_[1] &= ~0x00000002u;
  ::opencv_caffe::PReLUParameter* temp = _impl_.prelu_param_;
  _impl_.prelu_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PReLUParameter* LayerParameter::_internal_mutable_prelu_param() {
  _impl_._has_bits_[1] |= 0x00000002u;
  if (_impl_.prelu_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PReLUParameter>(GetArenaForAllocation());
    _impl_.prelu_param_ = p;
  }
  return _impl_.prelu_param_;
}
inline ::opencv_caffe::PReLUParameter* LayerParameter::mutable_prelu_param() {
  ::opencv_caffe::PReLUParameter* _msg = _internal_mutable_prelu_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.prelu_param)
  return _msg;
}
inline void LayerParameter::set_allocated_prelu_param(::opencv_caffe::PReLUParameter* prelu_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.prelu_param_;
  }
  if (prelu_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(prelu_param);
    if (message_arena != submessage_arena) {
      prelu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, prelu_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000002u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000002u;
  }
  _impl_.prelu_param_ = prelu_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.prelu_param)
}

// optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
inline bool LayerParameter::_internal_has_prior_box_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00100000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.prior_box_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_prior_box_param() const {
  return _internal_has_prior_box_param();
}
inline void LayerParameter::clear_prior_box_param() {
  if (_impl_.prior_box_param_ != nullptr) _impl_.prior_box_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00100000u;
}
inline const ::opencv_caffe::PriorBoxParameter& LayerParameter::_internal_prior_box_param() const {
  const ::opencv_caffe::PriorBoxParameter* p = _impl_.prior_box_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PriorBoxParameter&>(
      ::opencv_caffe::_PriorBoxParameter_default_instance_);
}
inline const ::opencv_caffe::PriorBoxParameter& LayerParameter::prior_box_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.prior_box_param)
  return _internal_prior_box_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_prior_box_param(
    ::opencv_caffe::PriorBoxParameter* prior_box_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.prior_box_param_);
  }
  _impl_.prior_box_param_ = prior_box_param;
  if (prior_box_param) {
    _impl_._has_bits_[1] |= 0x00100000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00100000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.prior_box_param)
}
inline ::opencv_caffe::PriorBoxParameter* LayerParameter::release_prior_box_param() {
  _impl_._has_bits_[1] &= ~0x00100000u;
  ::opencv_caffe::PriorBoxParameter* temp = _impl_.prior_box_param_;
  _impl_.prior_box_param_ = 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 ::opencv_caffe::PriorBoxParameter* LayerParameter::unsafe_arena_release_prior_box_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.prior_box_param)
  _impl_._has_bits_[1] &= ~0x00100000u;
  ::opencv_caffe::PriorBoxParameter* temp = _impl_.prior_box_param_;
  _impl_.prior_box_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PriorBoxParameter* LayerParameter::_internal_mutable_prior_box_param() {
  _impl_._has_bits_[1] |= 0x00100000u;
  if (_impl_.prior_box_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PriorBoxParameter>(GetArenaForAllocation());
    _impl_.prior_box_param_ = p;
  }
  return _impl_.prior_box_param_;
}
inline ::opencv_caffe::PriorBoxParameter* LayerParameter::mutable_prior_box_param() {
  ::opencv_caffe::PriorBoxParameter* _msg = _internal_mutable_prior_box_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.prior_box_param)
  return _msg;
}
inline void LayerParameter::set_allocated_prior_box_param(::opencv_caffe::PriorBoxParameter* prior_box_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.prior_box_param_;
  }
  if (prior_box_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(prior_box_param);
    if (message_arena != submessage_arena) {
      prior_box_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, prior_box_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00100000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00100000u;
  }
  _impl_.prior_box_param_ = prior_box_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.prior_box_param)
}

// optional .opencv_caffe.ProposalParameter proposal_param = 201;
inline bool LayerParameter::_internal_has_proposal_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00200000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.proposal_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_proposal_param() const {
  return _internal_has_proposal_param();
}
inline void LayerParameter::clear_proposal_param() {
  if (_impl_.proposal_param_ != nullptr) _impl_.proposal_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00200000u;
}
inline const ::opencv_caffe::ProposalParameter& LayerParameter::_internal_proposal_param() const {
  const ::opencv_caffe::ProposalParameter* p = _impl_.proposal_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ProposalParameter&>(
      ::opencv_caffe::_ProposalParameter_default_instance_);
}
inline const ::opencv_caffe::ProposalParameter& LayerParameter::proposal_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.proposal_param)
  return _internal_proposal_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_proposal_param(
    ::opencv_caffe::ProposalParameter* proposal_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.proposal_param_);
  }
  _impl_.proposal_param_ = proposal_param;
  if (proposal_param) {
    _impl_._has_bits_[1] |= 0x00200000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00200000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.proposal_param)
}
inline ::opencv_caffe::ProposalParameter* LayerParameter::release_proposal_param() {
  _impl_._has_bits_[1] &= ~0x00200000u;
  ::opencv_caffe::ProposalParameter* temp = _impl_.proposal_param_;
  _impl_.proposal_param_ = 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 ::opencv_caffe::ProposalParameter* LayerParameter::unsafe_arena_release_proposal_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.proposal_param)
  _impl_._has_bits_[1] &= ~0x00200000u;
  ::opencv_caffe::ProposalParameter* temp = _impl_.proposal_param_;
  _impl_.proposal_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ProposalParameter* LayerParameter::_internal_mutable_proposal_param() {
  _impl_._has_bits_[1] |= 0x00200000u;
  if (_impl_.proposal_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ProposalParameter>(GetArenaForAllocation());
    _impl_.proposal_param_ = p;
  }
  return _impl_.proposal_param_;
}
inline ::opencv_caffe::ProposalParameter* LayerParameter::mutable_proposal_param() {
  ::opencv_caffe::ProposalParameter* _msg = _internal_mutable_proposal_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.proposal_param)
  return _msg;
}
inline void LayerParameter::set_allocated_proposal_param(::opencv_caffe::ProposalParameter* proposal_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.proposal_param_;
  }
  if (proposal_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(proposal_param);
    if (message_arena != submessage_arena) {
      proposal_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, proposal_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00200000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00200000u;
  }
  _impl_.proposal_param_ = proposal_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.proposal_param)
}

// optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
inline bool LayerParameter::_internal_has_psroi_pooling_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00400000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.psroi_pooling_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_psroi_pooling_param() const {
  return _internal_has_psroi_pooling_param();
}
inline void LayerParameter::clear_psroi_pooling_param() {
  if (_impl_.psroi_pooling_param_ != nullptr) _impl_.psroi_pooling_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00400000u;
}
inline const ::opencv_caffe::PSROIPoolingParameter& LayerParameter::_internal_psroi_pooling_param() const {
  const ::opencv_caffe::PSROIPoolingParameter* p = _impl_.psroi_pooling_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PSROIPoolingParameter&>(
      ::opencv_caffe::_PSROIPoolingParameter_default_instance_);
}
inline const ::opencv_caffe::PSROIPoolingParameter& LayerParameter::psroi_pooling_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.psroi_pooling_param)
  return _internal_psroi_pooling_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_psroi_pooling_param(
    ::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.psroi_pooling_param_);
  }
  _impl_.psroi_pooling_param_ = psroi_pooling_param;
  if (psroi_pooling_param) {
    _impl_._has_bits_[1] |= 0x00400000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00400000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.psroi_pooling_param)
}
inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::release_psroi_pooling_param() {
  _impl_._has_bits_[1] &= ~0x00400000u;
  ::opencv_caffe::PSROIPoolingParameter* temp = _impl_.psroi_pooling_param_;
  _impl_.psroi_pooling_param_ = 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 ::opencv_caffe::PSROIPoolingParameter* LayerParameter::unsafe_arena_release_psroi_pooling_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.psroi_pooling_param)
  _impl_._has_bits_[1] &= ~0x00400000u;
  ::opencv_caffe::PSROIPoolingParameter* temp = _impl_.psroi_pooling_param_;
  _impl_.psroi_pooling_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::_internal_mutable_psroi_pooling_param() {
  _impl_._has_bits_[1] |= 0x00400000u;
  if (_impl_.psroi_pooling_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PSROIPoolingParameter>(GetArenaForAllocation());
    _impl_.psroi_pooling_param_ = p;
  }
  return _impl_.psroi_pooling_param_;
}
inline ::opencv_caffe::PSROIPoolingParameter* LayerParameter::mutable_psroi_pooling_param() {
  ::opencv_caffe::PSROIPoolingParameter* _msg = _internal_mutable_psroi_pooling_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.psroi_pooling_param)
  return _msg;
}
inline void LayerParameter::set_allocated_psroi_pooling_param(::opencv_caffe::PSROIPoolingParameter* psroi_pooling_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.psroi_pooling_param_;
  }
  if (psroi_pooling_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(psroi_pooling_param);
    if (message_arena != submessage_arena) {
      psroi_pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, psroi_pooling_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00400000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00400000u;
  }
  _impl_.psroi_pooling_param_ = psroi_pooling_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.psroi_pooling_param)
}

// optional .opencv_caffe.PythonParameter python_param = 130;
inline bool LayerParameter::_internal_has_python_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.python_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_python_param() const {
  return _internal_has_python_param();
}
inline void LayerParameter::clear_python_param() {
  if (_impl_.python_param_ != nullptr) _impl_.python_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline const ::opencv_caffe::PythonParameter& LayerParameter::_internal_python_param() const {
  const ::opencv_caffe::PythonParameter* p = _impl_.python_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PythonParameter&>(
      ::opencv_caffe::_PythonParameter_default_instance_);
}
inline const ::opencv_caffe::PythonParameter& LayerParameter::python_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.python_param)
  return _internal_python_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_python_param(
    ::opencv_caffe::PythonParameter* python_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.python_param_);
  }
  _impl_.python_param_ = python_param;
  if (python_param) {
    _impl_._has_bits_[1] |= 0x00000001u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.python_param)
}
inline ::opencv_caffe::PythonParameter* LayerParameter::release_python_param() {
  _impl_._has_bits_[1] &= ~0x00000001u;
  ::opencv_caffe::PythonParameter* temp = _impl_.python_param_;
  _impl_.python_param_ = 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 ::opencv_caffe::PythonParameter* LayerParameter::unsafe_arena_release_python_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.python_param)
  _impl_._has_bits_[1] &= ~0x00000001u;
  ::opencv_caffe::PythonParameter* temp = _impl_.python_param_;
  _impl_.python_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PythonParameter* LayerParameter::_internal_mutable_python_param() {
  _impl_._has_bits_[1] |= 0x00000001u;
  if (_impl_.python_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PythonParameter>(GetArenaForAllocation());
    _impl_.python_param_ = p;
  }
  return _impl_.python_param_;
}
inline ::opencv_caffe::PythonParameter* LayerParameter::mutable_python_param() {
  ::opencv_caffe::PythonParameter* _msg = _internal_mutable_python_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.python_param)
  return _msg;
}
inline void LayerParameter::set_allocated_python_param(::opencv_caffe::PythonParameter* python_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.python_param_;
  }
  if (python_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(python_param);
    if (message_arena != submessage_arena) {
      python_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, python_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000001u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000001u;
  }
  _impl_.python_param_ = python_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.python_param)
}

// optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
inline bool LayerParameter::_internal_has_recurrent_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.recurrent_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_recurrent_param() const {
  return _internal_has_recurrent_param();
}
inline void LayerParameter::clear_recurrent_param() {
  if (_impl_.recurrent_param_ != nullptr) _impl_.recurrent_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00010000u;
}
inline const ::opencv_caffe::RecurrentParameter& LayerParameter::_internal_recurrent_param() const {
  const ::opencv_caffe::RecurrentParameter* p = _impl_.recurrent_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::RecurrentParameter&>(
      ::opencv_caffe::_RecurrentParameter_default_instance_);
}
inline const ::opencv_caffe::RecurrentParameter& LayerParameter::recurrent_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.recurrent_param)
  return _internal_recurrent_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_recurrent_param(
    ::opencv_caffe::RecurrentParameter* recurrent_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.recurrent_param_);
  }
  _impl_.recurrent_param_ = recurrent_param;
  if (recurrent_param) {
    _impl_._has_bits_[1] |= 0x00010000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.recurrent_param)
}
inline ::opencv_caffe::RecurrentParameter* LayerParameter::release_recurrent_param() {
  _impl_._has_bits_[1] &= ~0x00010000u;
  ::opencv_caffe::RecurrentParameter* temp = _impl_.recurrent_param_;
  _impl_.recurrent_param_ = 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 ::opencv_caffe::RecurrentParameter* LayerParameter::unsafe_arena_release_recurrent_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.recurrent_param)
  _impl_._has_bits_[1] &= ~0x00010000u;
  ::opencv_caffe::RecurrentParameter* temp = _impl_.recurrent_param_;
  _impl_.recurrent_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::RecurrentParameter* LayerParameter::_internal_mutable_recurrent_param() {
  _impl_._has_bits_[1] |= 0x00010000u;
  if (_impl_.recurrent_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::RecurrentParameter>(GetArenaForAllocation());
    _impl_.recurrent_param_ = p;
  }
  return _impl_.recurrent_param_;
}
inline ::opencv_caffe::RecurrentParameter* LayerParameter::mutable_recurrent_param() {
  ::opencv_caffe::RecurrentParameter* _msg = _internal_mutable_recurrent_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.recurrent_param)
  return _msg;
}
inline void LayerParameter::set_allocated_recurrent_param(::opencv_caffe::RecurrentParameter* recurrent_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.recurrent_param_;
  }
  if (recurrent_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(recurrent_param);
    if (message_arena != submessage_arena) {
      recurrent_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, recurrent_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00010000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00010000u;
  }
  _impl_.recurrent_param_ = recurrent_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.recurrent_param)
}

// optional .opencv_caffe.ReductionParameter reduction_param = 136;
inline bool LayerParameter::_internal_has_reduction_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.reduction_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_reduction_param() const {
  return _internal_has_reduction_param();
}
inline void LayerParameter::clear_reduction_param() {
  if (_impl_.reduction_param_ != nullptr) _impl_.reduction_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline const ::opencv_caffe::ReductionParameter& LayerParameter::_internal_reduction_param() const {
  const ::opencv_caffe::ReductionParameter* p = _impl_.reduction_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ReductionParameter&>(
      ::opencv_caffe::_ReductionParameter_default_instance_);
}
inline const ::opencv_caffe::ReductionParameter& LayerParameter::reduction_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.reduction_param)
  return _internal_reduction_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_reduction_param(
    ::opencv_caffe::ReductionParameter* reduction_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reduction_param_);
  }
  _impl_.reduction_param_ = reduction_param;
  if (reduction_param) {
    _impl_._has_bits_[1] |= 0x00000040u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.reduction_param)
}
inline ::opencv_caffe::ReductionParameter* LayerParameter::release_reduction_param() {
  _impl_._has_bits_[1] &= ~0x00000040u;
  ::opencv_caffe::ReductionParameter* temp = _impl_.reduction_param_;
  _impl_.reduction_param_ = 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 ::opencv_caffe::ReductionParameter* LayerParameter::unsafe_arena_release_reduction_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.reduction_param)
  _impl_._has_bits_[1] &= ~0x00000040u;
  ::opencv_caffe::ReductionParameter* temp = _impl_.reduction_param_;
  _impl_.reduction_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ReductionParameter* LayerParameter::_internal_mutable_reduction_param() {
  _impl_._has_bits_[1] |= 0x00000040u;
  if (_impl_.reduction_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ReductionParameter>(GetArenaForAllocation());
    _impl_.reduction_param_ = p;
  }
  return _impl_.reduction_param_;
}
inline ::opencv_caffe::ReductionParameter* LayerParameter::mutable_reduction_param() {
  ::opencv_caffe::ReductionParameter* _msg = _internal_mutable_reduction_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.reduction_param)
  return _msg;
}
inline void LayerParameter::set_allocated_reduction_param(::opencv_caffe::ReductionParameter* reduction_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.reduction_param_;
  }
  if (reduction_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reduction_param);
    if (message_arena != submessage_arena) {
      reduction_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reduction_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000040u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000040u;
  }
  _impl_.reduction_param_ = reduction_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.reduction_param)
}

// optional .opencv_caffe.ReLUParameter relu_param = 123;
inline bool LayerParameter::_internal_has_relu_param() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relu_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_relu_param() const {
  return _internal_has_relu_param();
}
inline void LayerParameter::clear_relu_param() {
  if (_impl_.relu_param_ != nullptr) _impl_.relu_param_->Clear();
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline const ::opencv_caffe::ReLUParameter& LayerParameter::_internal_relu_param() const {
  const ::opencv_caffe::ReLUParameter* p = _impl_.relu_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ReLUParameter&>(
      ::opencv_caffe::_ReLUParameter_default_instance_);
}
inline const ::opencv_caffe::ReLUParameter& LayerParameter::relu_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.relu_param)
  return _internal_relu_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_relu_param(
    ::opencv_caffe::ReLUParameter* relu_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relu_param_);
  }
  _impl_.relu_param_ = relu_param;
  if (relu_param) {
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.relu_param)
}
inline ::opencv_caffe::ReLUParameter* LayerParameter::release_relu_param() {
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::opencv_caffe::ReLUParameter* temp = _impl_.relu_param_;
  _impl_.relu_param_ = 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 ::opencv_caffe::ReLUParameter* LayerParameter::unsafe_arena_release_relu_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.relu_param)
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::opencv_caffe::ReLUParameter* temp = _impl_.relu_param_;
  _impl_.relu_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ReLUParameter* LayerParameter::_internal_mutable_relu_param() {
  _impl_._has_bits_[0] |= 0x02000000u;
  if (_impl_.relu_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ReLUParameter>(GetArenaForAllocation());
    _impl_.relu_param_ = p;
  }
  return _impl_.relu_param_;
}
inline ::opencv_caffe::ReLUParameter* LayerParameter::mutable_relu_param() {
  ::opencv_caffe::ReLUParameter* _msg = _internal_mutable_relu_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.relu_param)
  return _msg;
}
inline void LayerParameter::set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.relu_param_;
  }
  if (relu_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relu_param);
    if (message_arena != submessage_arena) {
      relu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relu_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  _impl_.relu_param_ = relu_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.relu_param)
}

// optional .opencv_caffe.ReshapeParameter reshape_param = 133;
inline bool LayerParameter::_internal_has_reshape_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.reshape_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_reshape_param() const {
  return _internal_has_reshape_param();
}
inline void LayerParameter::clear_reshape_param() {
  if (_impl_.reshape_param_ != nullptr) _impl_.reshape_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline const ::opencv_caffe::ReshapeParameter& LayerParameter::_internal_reshape_param() const {
  const ::opencv_caffe::ReshapeParameter* p = _impl_.reshape_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ReshapeParameter&>(
      ::opencv_caffe::_ReshapeParameter_default_instance_);
}
inline const ::opencv_caffe::ReshapeParameter& LayerParameter::reshape_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.reshape_param)
  return _internal_reshape_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_reshape_param(
    ::opencv_caffe::ReshapeParameter* reshape_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reshape_param_);
  }
  _impl_.reshape_param_ = reshape_param;
  if (reshape_param) {
    _impl_._has_bits_[1] |= 0x00000008u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.reshape_param)
}
inline ::opencv_caffe::ReshapeParameter* LayerParameter::release_reshape_param() {
  _impl_._has_bits_[1] &= ~0x00000008u;
  ::opencv_caffe::ReshapeParameter* temp = _impl_.reshape_param_;
  _impl_.reshape_param_ = 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 ::opencv_caffe::ReshapeParameter* LayerParameter::unsafe_arena_release_reshape_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.reshape_param)
  _impl_._has_bits_[1] &= ~0x00000008u;
  ::opencv_caffe::ReshapeParameter* temp = _impl_.reshape_param_;
  _impl_.reshape_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ReshapeParameter* LayerParameter::_internal_mutable_reshape_param() {
  _impl_._has_bits_[1] |= 0x00000008u;
  if (_impl_.reshape_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ReshapeParameter>(GetArenaForAllocation());
    _impl_.reshape_param_ = p;
  }
  return _impl_.reshape_param_;
}
inline ::opencv_caffe::ReshapeParameter* LayerParameter::mutable_reshape_param() {
  ::opencv_caffe::ReshapeParameter* _msg = _internal_mutable_reshape_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.reshape_param)
  return _msg;
}
inline void LayerParameter::set_allocated_reshape_param(::opencv_caffe::ReshapeParameter* reshape_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.reshape_param_;
  }
  if (reshape_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reshape_param);
    if (message_arena != submessage_arena) {
      reshape_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reshape_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000008u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000008u;
  }
  _impl_.reshape_param_ = reshape_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.reshape_param)
}

// optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
inline bool LayerParameter::_internal_has_roi_pooling_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00800000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.roi_pooling_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_roi_pooling_param() const {
  return _internal_has_roi_pooling_param();
}
inline void LayerParameter::clear_roi_pooling_param() {
  if (_impl_.roi_pooling_param_ != nullptr) _impl_.roi_pooling_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00800000u;
}
inline const ::opencv_caffe::ROIPoolingParameter& LayerParameter::_internal_roi_pooling_param() const {
  const ::opencv_caffe::ROIPoolingParameter* p = _impl_.roi_pooling_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ROIPoolingParameter&>(
      ::opencv_caffe::_ROIPoolingParameter_default_instance_);
}
inline const ::opencv_caffe::ROIPoolingParameter& LayerParameter::roi_pooling_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.roi_pooling_param)
  return _internal_roi_pooling_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_roi_pooling_param(
    ::opencv_caffe::ROIPoolingParameter* roi_pooling_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.roi_pooling_param_);
  }
  _impl_.roi_pooling_param_ = roi_pooling_param;
  if (roi_pooling_param) {
    _impl_._has_bits_[1] |= 0x00800000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00800000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.roi_pooling_param)
}
inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::release_roi_pooling_param() {
  _impl_._has_bits_[1] &= ~0x00800000u;
  ::opencv_caffe::ROIPoolingParameter* temp = _impl_.roi_pooling_param_;
  _impl_.roi_pooling_param_ = 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 ::opencv_caffe::ROIPoolingParameter* LayerParameter::unsafe_arena_release_roi_pooling_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.roi_pooling_param)
  _impl_._has_bits_[1] &= ~0x00800000u;
  ::opencv_caffe::ROIPoolingParameter* temp = _impl_.roi_pooling_param_;
  _impl_.roi_pooling_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::_internal_mutable_roi_pooling_param() {
  _impl_._has_bits_[1] |= 0x00800000u;
  if (_impl_.roi_pooling_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ROIPoolingParameter>(GetArenaForAllocation());
    _impl_.roi_pooling_param_ = p;
  }
  return _impl_.roi_pooling_param_;
}
inline ::opencv_caffe::ROIPoolingParameter* LayerParameter::mutable_roi_pooling_param() {
  ::opencv_caffe::ROIPoolingParameter* _msg = _internal_mutable_roi_pooling_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.roi_pooling_param)
  return _msg;
}
inline void LayerParameter::set_allocated_roi_pooling_param(::opencv_caffe::ROIPoolingParameter* roi_pooling_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.roi_pooling_param_;
  }
  if (roi_pooling_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(roi_pooling_param);
    if (message_arena != submessage_arena) {
      roi_pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, roi_pooling_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00800000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00800000u;
  }
  _impl_.roi_pooling_param_ = roi_pooling_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.roi_pooling_param)
}

// optional .opencv_caffe.ScaleParameter scale_param = 142;
inline bool LayerParameter::_internal_has_scale_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.scale_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_scale_param() const {
  return _internal_has_scale_param();
}
inline void LayerParameter::clear_scale_param() {
  if (_impl_.scale_param_ != nullptr) _impl_.scale_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline const ::opencv_caffe::ScaleParameter& LayerParameter::_internal_scale_param() const {
  const ::opencv_caffe::ScaleParameter* p = _impl_.scale_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ScaleParameter&>(
      ::opencv_caffe::_ScaleParameter_default_instance_);
}
inline const ::opencv_caffe::ScaleParameter& LayerParameter::scale_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.scale_param)
  return _internal_scale_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_scale_param(
    ::opencv_caffe::ScaleParameter* scale_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.scale_param_);
  }
  _impl_.scale_param_ = scale_param;
  if (scale_param) {
    _impl_._has_bits_[1] |= 0x00001000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.scale_param)
}
inline ::opencv_caffe::ScaleParameter* LayerParameter::release_scale_param() {
  _impl_._has_bits_[1] &= ~0x00001000u;
  ::opencv_caffe::ScaleParameter* temp = _impl_.scale_param_;
  _impl_.scale_param_ = 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 ::opencv_caffe::ScaleParameter* LayerParameter::unsafe_arena_release_scale_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.scale_param)
  _impl_._has_bits_[1] &= ~0x00001000u;
  ::opencv_caffe::ScaleParameter* temp = _impl_.scale_param_;
  _impl_.scale_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ScaleParameter* LayerParameter::_internal_mutable_scale_param() {
  _impl_._has_bits_[1] |= 0x00001000u;
  if (_impl_.scale_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ScaleParameter>(GetArenaForAllocation());
    _impl_.scale_param_ = p;
  }
  return _impl_.scale_param_;
}
inline ::opencv_caffe::ScaleParameter* LayerParameter::mutable_scale_param() {
  ::opencv_caffe::ScaleParameter* _msg = _internal_mutable_scale_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.scale_param)
  return _msg;
}
inline void LayerParameter::set_allocated_scale_param(::opencv_caffe::ScaleParameter* scale_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.scale_param_;
  }
  if (scale_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(scale_param);
    if (message_arena != submessage_arena) {
      scale_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scale_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00001000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00001000u;
  }
  _impl_.scale_param_ = scale_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.scale_param)
}

// optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
inline bool LayerParameter::_internal_has_sigmoid_param() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sigmoid_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_sigmoid_param() const {
  return _internal_has_sigmoid_param();
}
inline void LayerParameter::clear_sigmoid_param() {
  if (_impl_.sigmoid_param_ != nullptr) _impl_.sigmoid_param_->Clear();
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline const ::opencv_caffe::SigmoidParameter& LayerParameter::_internal_sigmoid_param() const {
  const ::opencv_caffe::SigmoidParameter* p = _impl_.sigmoid_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SigmoidParameter&>(
      ::opencv_caffe::_SigmoidParameter_default_instance_);
}
inline const ::opencv_caffe::SigmoidParameter& LayerParameter::sigmoid_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.sigmoid_param)
  return _internal_sigmoid_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_sigmoid_param(
    ::opencv_caffe::SigmoidParameter* sigmoid_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sigmoid_param_);
  }
  _impl_.sigmoid_param_ = sigmoid_param;
  if (sigmoid_param) {
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.sigmoid_param)
}
inline ::opencv_caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() {
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::opencv_caffe::SigmoidParameter* temp = _impl_.sigmoid_param_;
  _impl_.sigmoid_param_ = 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 ::opencv_caffe::SigmoidParameter* LayerParameter::unsafe_arena_release_sigmoid_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.sigmoid_param)
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::opencv_caffe::SigmoidParameter* temp = _impl_.sigmoid_param_;
  _impl_.sigmoid_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SigmoidParameter* LayerParameter::_internal_mutable_sigmoid_param() {
  _impl_._has_bits_[0] |= 0x04000000u;
  if (_impl_.sigmoid_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SigmoidParameter>(GetArenaForAllocation());
    _impl_.sigmoid_param_ = p;
  }
  return _impl_.sigmoid_param_;
}
inline ::opencv_caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() {
  ::opencv_caffe::SigmoidParameter* _msg = _internal_mutable_sigmoid_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.sigmoid_param)
  return _msg;
}
inline void LayerParameter::set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sigmoid_param_;
  }
  if (sigmoid_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sigmoid_param);
    if (message_arena != submessage_arena) {
      sigmoid_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sigmoid_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  _impl_.sigmoid_param_ = sigmoid_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.sigmoid_param)
}

// optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
inline bool LayerParameter::_internal_has_softmax_param() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.softmax_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_softmax_param() const {
  return _internal_has_softmax_param();
}
inline void LayerParameter::clear_softmax_param() {
  if (_impl_.softmax_param_ != nullptr) _impl_.softmax_param_->Clear();
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline const ::opencv_caffe::SoftmaxParameter& LayerParameter::_internal_softmax_param() const {
  const ::opencv_caffe::SoftmaxParameter* p = _impl_.softmax_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SoftmaxParameter&>(
      ::opencv_caffe::_SoftmaxParameter_default_instance_);
}
inline const ::opencv_caffe::SoftmaxParameter& LayerParameter::softmax_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.softmax_param)
  return _internal_softmax_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_softmax_param(
    ::opencv_caffe::SoftmaxParameter* softmax_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.softmax_param_);
  }
  _impl_.softmax_param_ = softmax_param;
  if (softmax_param) {
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.softmax_param)
}
inline ::opencv_caffe::SoftmaxParameter* LayerParameter::release_softmax_param() {
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::opencv_caffe::SoftmaxParameter* temp = _impl_.softmax_param_;
  _impl_.softmax_param_ = 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 ::opencv_caffe::SoftmaxParameter* LayerParameter::unsafe_arena_release_softmax_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.softmax_param)
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::opencv_caffe::SoftmaxParameter* temp = _impl_.softmax_param_;
  _impl_.softmax_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SoftmaxParameter* LayerParameter::_internal_mutable_softmax_param() {
  _impl_._has_bits_[0] |= 0x08000000u;
  if (_impl_.softmax_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SoftmaxParameter>(GetArenaForAllocation());
    _impl_.softmax_param_ = p;
  }
  return _impl_.softmax_param_;
}
inline ::opencv_caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() {
  ::opencv_caffe::SoftmaxParameter* _msg = _internal_mutable_softmax_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.softmax_param)
  return _msg;
}
inline void LayerParameter::set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.softmax_param_;
  }
  if (softmax_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(softmax_param);
    if (message_arena != submessage_arena) {
      softmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, softmax_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  _impl_.softmax_param_ = softmax_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.softmax_param)
}

// optional .opencv_caffe.SPPParameter spp_param = 132;
inline bool LayerParameter::_internal_has_spp_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.spp_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_spp_param() const {
  return _internal_has_spp_param();
}
inline void LayerParameter::clear_spp_param() {
  if (_impl_.spp_param_ != nullptr) _impl_.spp_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline const ::opencv_caffe::SPPParameter& LayerParameter::_internal_spp_param() const {
  const ::opencv_caffe::SPPParameter* p = _impl_.spp_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SPPParameter&>(
      ::opencv_caffe::_SPPParameter_default_instance_);
}
inline const ::opencv_caffe::SPPParameter& LayerParameter::spp_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.spp_param)
  return _internal_spp_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_spp_param(
    ::opencv_caffe::SPPParameter* spp_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.spp_param_);
  }
  _impl_.spp_param_ = spp_param;
  if (spp_param) {
    _impl_._has_bits_[1] |= 0x00000004u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.spp_param)
}
inline ::opencv_caffe::SPPParameter* LayerParameter::release_spp_param() {
  _impl_._has_bits_[1] &= ~0x00000004u;
  ::opencv_caffe::SPPParameter* temp = _impl_.spp_param_;
  _impl_.spp_param_ = 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 ::opencv_caffe::SPPParameter* LayerParameter::unsafe_arena_release_spp_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.spp_param)
  _impl_._has_bits_[1] &= ~0x00000004u;
  ::opencv_caffe::SPPParameter* temp = _impl_.spp_param_;
  _impl_.spp_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SPPParameter* LayerParameter::_internal_mutable_spp_param() {
  _impl_._has_bits_[1] |= 0x00000004u;
  if (_impl_.spp_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SPPParameter>(GetArenaForAllocation());
    _impl_.spp_param_ = p;
  }
  return _impl_.spp_param_;
}
inline ::opencv_caffe::SPPParameter* LayerParameter::mutable_spp_param() {
  ::opencv_caffe::SPPParameter* _msg = _internal_mutable_spp_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.spp_param)
  return _msg;
}
inline void LayerParameter::set_allocated_spp_param(::opencv_caffe::SPPParameter* spp_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.spp_param_;
  }
  if (spp_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(spp_param);
    if (message_arena != submessage_arena) {
      spp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, spp_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000004u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000004u;
  }
  _impl_.spp_param_ = spp_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.spp_param)
}

// optional .opencv_caffe.SliceParameter slice_param = 126;
inline bool LayerParameter::_internal_has_slice_param() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.slice_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_slice_param() const {
  return _internal_has_slice_param();
}
inline void LayerParameter::clear_slice_param() {
  if (_impl_.slice_param_ != nullptr) _impl_.slice_param_->Clear();
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline const ::opencv_caffe::SliceParameter& LayerParameter::_internal_slice_param() const {
  const ::opencv_caffe::SliceParameter* p = _impl_.slice_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SliceParameter&>(
      ::opencv_caffe::_SliceParameter_default_instance_);
}
inline const ::opencv_caffe::SliceParameter& LayerParameter::slice_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.slice_param)
  return _internal_slice_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_slice_param(
    ::opencv_caffe::SliceParameter* slice_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.slice_param_);
  }
  _impl_.slice_param_ = slice_param;
  if (slice_param) {
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.slice_param)
}
inline ::opencv_caffe::SliceParameter* LayerParameter::release_slice_param() {
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::opencv_caffe::SliceParameter* temp = _impl_.slice_param_;
  _impl_.slice_param_ = 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 ::opencv_caffe::SliceParameter* LayerParameter::unsafe_arena_release_slice_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.slice_param)
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::opencv_caffe::SliceParameter* temp = _impl_.slice_param_;
  _impl_.slice_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SliceParameter* LayerParameter::_internal_mutable_slice_param() {
  _impl_._has_bits_[0] |= 0x10000000u;
  if (_impl_.slice_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SliceParameter>(GetArenaForAllocation());
    _impl_.slice_param_ = p;
  }
  return _impl_.slice_param_;
}
inline ::opencv_caffe::SliceParameter* LayerParameter::mutable_slice_param() {
  ::opencv_caffe::SliceParameter* _msg = _internal_mutable_slice_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.slice_param)
  return _msg;
}
inline void LayerParameter::set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.slice_param_;
  }
  if (slice_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(slice_param);
    if (message_arena != submessage_arena) {
      slice_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, slice_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  _impl_.slice_param_ = slice_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.slice_param)
}

// optional .opencv_caffe.TanHParameter tanh_param = 127;
inline bool LayerParameter::_internal_has_tanh_param() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tanh_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_tanh_param() const {
  return _internal_has_tanh_param();
}
inline void LayerParameter::clear_tanh_param() {
  if (_impl_.tanh_param_ != nullptr) _impl_.tanh_param_->Clear();
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline const ::opencv_caffe::TanHParameter& LayerParameter::_internal_tanh_param() const {
  const ::opencv_caffe::TanHParameter* p = _impl_.tanh_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::TanHParameter&>(
      ::opencv_caffe::_TanHParameter_default_instance_);
}
inline const ::opencv_caffe::TanHParameter& LayerParameter::tanh_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.tanh_param)
  return _internal_tanh_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_tanh_param(
    ::opencv_caffe::TanHParameter* tanh_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tanh_param_);
  }
  _impl_.tanh_param_ = tanh_param;
  if (tanh_param) {
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.tanh_param)
}
inline ::opencv_caffe::TanHParameter* LayerParameter::release_tanh_param() {
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::opencv_caffe::TanHParameter* temp = _impl_.tanh_param_;
  _impl_.tanh_param_ = 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 ::opencv_caffe::TanHParameter* LayerParameter::unsafe_arena_release_tanh_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.tanh_param)
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::opencv_caffe::TanHParameter* temp = _impl_.tanh_param_;
  _impl_.tanh_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::TanHParameter* LayerParameter::_internal_mutable_tanh_param() {
  _impl_._has_bits_[0] |= 0x20000000u;
  if (_impl_.tanh_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::TanHParameter>(GetArenaForAllocation());
    _impl_.tanh_param_ = p;
  }
  return _impl_.tanh_param_;
}
inline ::opencv_caffe::TanHParameter* LayerParameter::mutable_tanh_param() {
  ::opencv_caffe::TanHParameter* _msg = _internal_mutable_tanh_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.tanh_param)
  return _msg;
}
inline void LayerParameter::set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.tanh_param_;
  }
  if (tanh_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tanh_param);
    if (message_arena != submessage_arena) {
      tanh_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tanh_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  _impl_.tanh_param_ = tanh_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.tanh_param)
}

// optional .opencv_caffe.ThresholdParameter threshold_param = 128;
inline bool LayerParameter::_internal_has_threshold_param() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.threshold_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_threshold_param() const {
  return _internal_has_threshold_param();
}
inline void LayerParameter::clear_threshold_param() {
  if (_impl_.threshold_param_ != nullptr) _impl_.threshold_param_->Clear();
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline const ::opencv_caffe::ThresholdParameter& LayerParameter::_internal_threshold_param() const {
  const ::opencv_caffe::ThresholdParameter* p = _impl_.threshold_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ThresholdParameter&>(
      ::opencv_caffe::_ThresholdParameter_default_instance_);
}
inline const ::opencv_caffe::ThresholdParameter& LayerParameter::threshold_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.threshold_param)
  return _internal_threshold_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_threshold_param(
    ::opencv_caffe::ThresholdParameter* threshold_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threshold_param_);
  }
  _impl_.threshold_param_ = threshold_param;
  if (threshold_param) {
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.threshold_param)
}
inline ::opencv_caffe::ThresholdParameter* LayerParameter::release_threshold_param() {
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::opencv_caffe::ThresholdParameter* temp = _impl_.threshold_param_;
  _impl_.threshold_param_ = 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 ::opencv_caffe::ThresholdParameter* LayerParameter::unsafe_arena_release_threshold_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.threshold_param)
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::opencv_caffe::ThresholdParameter* temp = _impl_.threshold_param_;
  _impl_.threshold_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ThresholdParameter* LayerParameter::_internal_mutable_threshold_param() {
  _impl_._has_bits_[0] |= 0x40000000u;
  if (_impl_.threshold_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ThresholdParameter>(GetArenaForAllocation());
    _impl_.threshold_param_ = p;
  }
  return _impl_.threshold_param_;
}
inline ::opencv_caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() {
  ::opencv_caffe::ThresholdParameter* _msg = _internal_mutable_threshold_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.threshold_param)
  return _msg;
}
inline void LayerParameter::set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.threshold_param_;
  }
  if (threshold_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threshold_param);
    if (message_arena != submessage_arena) {
      threshold_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, threshold_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  _impl_.threshold_param_ = threshold_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.threshold_param)
}

// optional .opencv_caffe.TileParameter tile_param = 138;
inline bool LayerParameter::_internal_has_tile_param() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tile_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_tile_param() const {
  return _internal_has_tile_param();
}
inline void LayerParameter::clear_tile_param() {
  if (_impl_.tile_param_ != nullptr) _impl_.tile_param_->Clear();
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline const ::opencv_caffe::TileParameter& LayerParameter::_internal_tile_param() const {
  const ::opencv_caffe::TileParameter* p = _impl_.tile_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::TileParameter&>(
      ::opencv_caffe::_TileParameter_default_instance_);
}
inline const ::opencv_caffe::TileParameter& LayerParameter::tile_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.tile_param)
  return _internal_tile_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_tile_param(
    ::opencv_caffe::TileParameter* tile_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tile_param_);
  }
  _impl_.tile_param_ = tile_param;
  if (tile_param) {
    _impl_._has_bits_[1] |= 0x00000100u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.tile_param)
}
inline ::opencv_caffe::TileParameter* LayerParameter::release_tile_param() {
  _impl_._has_bits_[1] &= ~0x00000100u;
  ::opencv_caffe::TileParameter* temp = _impl_.tile_param_;
  _impl_.tile_param_ = 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 ::opencv_caffe::TileParameter* LayerParameter::unsafe_arena_release_tile_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.tile_param)
  _impl_._has_bits_[1] &= ~0x00000100u;
  ::opencv_caffe::TileParameter* temp = _impl_.tile_param_;
  _impl_.tile_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::TileParameter* LayerParameter::_internal_mutable_tile_param() {
  _impl_._has_bits_[1] |= 0x00000100u;
  if (_impl_.tile_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::TileParameter>(GetArenaForAllocation());
    _impl_.tile_param_ = p;
  }
  return _impl_.tile_param_;
}
inline ::opencv_caffe::TileParameter* LayerParameter::mutable_tile_param() {
  ::opencv_caffe::TileParameter* _msg = _internal_mutable_tile_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.tile_param)
  return _msg;
}
inline void LayerParameter::set_allocated_tile_param(::opencv_caffe::TileParameter* tile_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.tile_param_;
  }
  if (tile_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tile_param);
    if (message_arena != submessage_arena) {
      tile_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tile_param, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000100u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000100u;
  }
  _impl_.tile_param_ = tile_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.tile_param)
}

// optional .opencv_caffe.WindowDataParameter window_data_param = 129;
inline bool LayerParameter::_internal_has_window_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.window_data_param_ != nullptr);
  return value;
}
inline bool LayerParameter::has_window_data_param() const {
  return _internal_has_window_data_param();
}
inline void LayerParameter::clear_window_data_param() {
  if (_impl_.window_data_param_ != nullptr) _impl_.window_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline const ::opencv_caffe::WindowDataParameter& LayerParameter::_internal_window_data_param() const {
  const ::opencv_caffe::WindowDataParameter* p = _impl_.window_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::WindowDataParameter&>(
      ::opencv_caffe::_WindowDataParameter_default_instance_);
}
inline const ::opencv_caffe::WindowDataParameter& LayerParameter::window_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LayerParameter.window_data_param)
  return _internal_window_data_param();
}
inline void LayerParameter::unsafe_arena_set_allocated_window_data_param(
    ::opencv_caffe::WindowDataParameter* window_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.window_data_param_);
  }
  _impl_.window_data_param_ = window_data_param;
  if (window_data_param) {
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.LayerParameter.window_data_param)
}
inline ::opencv_caffe::WindowDataParameter* LayerParameter::release_window_data_param() {
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::opencv_caffe::WindowDataParameter* temp = _impl_.window_data_param_;
  _impl_.window_data_param_ = 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 ::opencv_caffe::WindowDataParameter* LayerParameter::unsafe_arena_release_window_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.LayerParameter.window_data_param)
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::opencv_caffe::WindowDataParameter* temp = _impl_.window_data_param_;
  _impl_.window_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::WindowDataParameter* LayerParameter::_internal_mutable_window_data_param() {
  _impl_._has_bits_[0] |= 0x80000000u;
  if (_impl_.window_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::WindowDataParameter>(GetArenaForAllocation());
    _impl_.window_data_param_ = p;
  }
  return _impl_.window_data_param_;
}
inline ::opencv_caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() {
  ::opencv_caffe::WindowDataParameter* _msg = _internal_mutable_window_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.LayerParameter.window_data_param)
  return _msg;
}
inline void LayerParameter::set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.window_data_param_;
  }
  if (window_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(window_data_param);
    if (message_arena != submessage_arena) {
      window_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, window_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  _impl_.window_data_param_ = window_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.LayerParameter.window_data_param)
}

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

// TransformationParameter

// optional float scale = 1 [default = 1];
inline bool TransformationParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool TransformationParameter::has_scale() const {
  return _internal_has_scale();
}
inline void TransformationParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float TransformationParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float TransformationParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.scale)
  return _internal_scale();
}
inline void TransformationParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.scale_ = value;
}
inline void TransformationParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.scale)
}

// optional bool mirror = 2 [default = false];
inline bool TransformationParameter::_internal_has_mirror() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TransformationParameter::has_mirror() const {
  return _internal_has_mirror();
}
inline void TransformationParameter::clear_mirror() {
  _impl_.mirror_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool TransformationParameter::_internal_mirror() const {
  return _impl_.mirror_;
}
inline bool TransformationParameter::mirror() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mirror)
  return _internal_mirror();
}
inline void TransformationParameter::_internal_set_mirror(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mirror_ = value;
}
inline void TransformationParameter::set_mirror(bool value) {
  _internal_set_mirror(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mirror)
}

// optional uint32 crop_size = 3 [default = 0];
inline bool TransformationParameter::_internal_has_crop_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TransformationParameter::has_crop_size() const {
  return _internal_has_crop_size();
}
inline void TransformationParameter::clear_crop_size() {
  _impl_.crop_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t TransformationParameter::_internal_crop_size() const {
  return _impl_.crop_size_;
}
inline uint32_t TransformationParameter::crop_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.crop_size)
  return _internal_crop_size();
}
inline void TransformationParameter::_internal_set_crop_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.crop_size_ = value;
}
inline void TransformationParameter::set_crop_size(uint32_t value) {
  _internal_set_crop_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.crop_size)
}

// optional string mean_file = 4;
inline bool TransformationParameter::_internal_has_mean_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TransformationParameter::has_mean_file() const {
  return _internal_has_mean_file();
}
inline void TransformationParameter::clear_mean_file() {
  _impl_.mean_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TransformationParameter::mean_file() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mean_file)
  return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TransformationParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.mean_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mean_file)
}
inline std::string* TransformationParameter::mutable_mean_file() {
  std::string* _s = _internal_mutable_mean_file();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.TransformationParameter.mean_file)
  return _s;
}
inline const std::string& TransformationParameter::_internal_mean_file() const {
  return _impl_.mean_file_.Get();
}
inline void TransformationParameter::_internal_set_mean_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mean_file_.Set(value, GetArenaForAllocation());
}
inline std::string* TransformationParameter::_internal_mutable_mean_file() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.mean_file_.Mutable(GetArenaForAllocation());
}
inline std::string* TransformationParameter::release_mean_file() {
  // @@protoc_insertion_point(field_release:opencv_caffe.TransformationParameter.mean_file)
  if (!_internal_has_mean_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.mean_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TransformationParameter::set_allocated_mean_file(std::string* mean_file) {
  if (mean_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mean_file_.SetAllocated(mean_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.TransformationParameter.mean_file)
}

// repeated float mean_value = 5;
inline int TransformationParameter::_internal_mean_value_size() const {
  return _impl_.mean_value_.size();
}
inline int TransformationParameter::mean_value_size() const {
  return _internal_mean_value_size();
}
inline void TransformationParameter::clear_mean_value() {
  _impl_.mean_value_.Clear();
}
inline float TransformationParameter::_internal_mean_value(int index) const {
  return _impl_.mean_value_.Get(index);
}
inline float TransformationParameter::mean_value(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.mean_value)
  return _internal_mean_value(index);
}
inline void TransformationParameter::set_mean_value(int index, float value) {
  _impl_.mean_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.mean_value)
}
inline void TransformationParameter::_internal_add_mean_value(float value) {
  _impl_.mean_value_.Add(value);
}
inline void TransformationParameter::add_mean_value(float value) {
  _internal_add_mean_value(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.TransformationParameter.mean_value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TransformationParameter::_internal_mean_value() const {
  return _impl_.mean_value_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TransformationParameter::mean_value() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.TransformationParameter.mean_value)
  return _internal_mean_value();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TransformationParameter::_internal_mutable_mean_value() {
  return &_impl_.mean_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TransformationParameter::mutable_mean_value() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.TransformationParameter.mean_value)
  return _internal_mutable_mean_value();
}

// optional bool force_color = 6 [default = false];
inline bool TransformationParameter::_internal_has_force_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool TransformationParameter::has_force_color() const {
  return _internal_has_force_color();
}
inline void TransformationParameter::clear_force_color() {
  _impl_.force_color_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool TransformationParameter::_internal_force_color() const {
  return _impl_.force_color_;
}
inline bool TransformationParameter::force_color() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.force_color)
  return _internal_force_color();
}
inline void TransformationParameter::_internal_set_force_color(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.force_color_ = value;
}
inline void TransformationParameter::set_force_color(bool value) {
  _internal_set_force_color(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.force_color)
}

// optional bool force_gray = 7 [default = false];
inline bool TransformationParameter::_internal_has_force_gray() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool TransformationParameter::has_force_gray() const {
  return _internal_has_force_gray();
}
inline void TransformationParameter::clear_force_gray() {
  _impl_.force_gray_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool TransformationParameter::_internal_force_gray() const {
  return _impl_.force_gray_;
}
inline bool TransformationParameter::force_gray() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TransformationParameter.force_gray)
  return _internal_force_gray();
}
inline void TransformationParameter::_internal_set_force_gray(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.force_gray_ = value;
}
inline void TransformationParameter::set_force_gray(bool value) {
  _internal_set_force_gray(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TransformationParameter.force_gray)
}

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

// LossParameter

// optional int32 ignore_label = 1;
inline bool LossParameter::_internal_has_ignore_label() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LossParameter::has_ignore_label() const {
  return _internal_has_ignore_label();
}
inline void LossParameter::clear_ignore_label() {
  _impl_.ignore_label_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t LossParameter::_internal_ignore_label() const {
  return _impl_.ignore_label_;
}
inline int32_t LossParameter::ignore_label() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.ignore_label)
  return _internal_ignore_label();
}
inline void LossParameter::_internal_set_ignore_label(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ignore_label_ = value;
}
inline void LossParameter::set_ignore_label(int32_t value) {
  _internal_set_ignore_label(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.ignore_label)
}

// optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
inline bool LossParameter::_internal_has_normalization() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LossParameter::has_normalization() const {
  return _internal_has_normalization();
}
inline void LossParameter::clear_normalization() {
  _impl_.normalization_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::opencv_caffe::LossParameter_NormalizationMode LossParameter::_internal_normalization() const {
  return static_cast< ::opencv_caffe::LossParameter_NormalizationMode >(_impl_.normalization_);
}
inline ::opencv_caffe::LossParameter_NormalizationMode LossParameter::normalization() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.normalization)
  return _internal_normalization();
}
inline void LossParameter::_internal_set_normalization(::opencv_caffe::LossParameter_NormalizationMode value) {
  assert(::opencv_caffe::LossParameter_NormalizationMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.normalization_ = value;
}
inline void LossParameter::set_normalization(::opencv_caffe::LossParameter_NormalizationMode value) {
  _internal_set_normalization(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.normalization)
}

// optional bool normalize = 2;
inline bool LossParameter::_internal_has_normalize() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LossParameter::has_normalize() const {
  return _internal_has_normalize();
}
inline void LossParameter::clear_normalize() {
  _impl_.normalize_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool LossParameter::_internal_normalize() const {
  return _impl_.normalize_;
}
inline bool LossParameter::normalize() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LossParameter.normalize)
  return _internal_normalize();
}
inline void LossParameter::_internal_set_normalize(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.normalize_ = value;
}
inline void LossParameter::set_normalize(bool value) {
  _internal_set_normalize(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LossParameter.normalize)
}

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

// AccuracyParameter

// optional uint32 top_k = 1 [default = 1];
inline bool AccuracyParameter::_internal_has_top_k() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool AccuracyParameter::has_top_k() const {
  return _internal_has_top_k();
}
inline void AccuracyParameter::clear_top_k() {
  _impl_.top_k_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t AccuracyParameter::_internal_top_k() const {
  return _impl_.top_k_;
}
inline uint32_t AccuracyParameter::top_k() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.top_k)
  return _internal_top_k();
}
inline void AccuracyParameter::_internal_set_top_k(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.top_k_ = value;
}
inline void AccuracyParameter::set_top_k(uint32_t value) {
  _internal_set_top_k(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.top_k)
}

// optional int32 axis = 2 [default = 1];
inline bool AccuracyParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool AccuracyParameter::has_axis() const {
  return _internal_has_axis();
}
inline void AccuracyParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t AccuracyParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t AccuracyParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.axis)
  return _internal_axis();
}
inline void AccuracyParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.axis_ = value;
}
inline void AccuracyParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.axis)
}

// optional int32 ignore_label = 3;
inline bool AccuracyParameter::_internal_has_ignore_label() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool AccuracyParameter::has_ignore_label() const {
  return _internal_has_ignore_label();
}
inline void AccuracyParameter::clear_ignore_label() {
  _impl_.ignore_label_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t AccuracyParameter::_internal_ignore_label() const {
  return _impl_.ignore_label_;
}
inline int32_t AccuracyParameter::ignore_label() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.AccuracyParameter.ignore_label)
  return _internal_ignore_label();
}
inline void AccuracyParameter::_internal_set_ignore_label(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ignore_label_ = value;
}
inline void AccuracyParameter::set_ignore_label(int32_t value) {
  _internal_set_ignore_label(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.AccuracyParameter.ignore_label)
}

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

// ArgMaxParameter

// optional bool out_max_val = 1 [default = false];
inline bool ArgMaxParameter::_internal_has_out_max_val() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ArgMaxParameter::has_out_max_val() const {
  return _internal_has_out_max_val();
}
inline void ArgMaxParameter::clear_out_max_val() {
  _impl_.out_max_val_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool ArgMaxParameter::_internal_out_max_val() const {
  return _impl_.out_max_val_;
}
inline bool ArgMaxParameter::out_max_val() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.out_max_val)
  return _internal_out_max_val();
}
inline void ArgMaxParameter::_internal_set_out_max_val(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.out_max_val_ = value;
}
inline void ArgMaxParameter::set_out_max_val(bool value) {
  _internal_set_out_max_val(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.out_max_val)
}

// optional uint32 top_k = 2 [default = 1];
inline bool ArgMaxParameter::_internal_has_top_k() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ArgMaxParameter::has_top_k() const {
  return _internal_has_top_k();
}
inline void ArgMaxParameter::clear_top_k() {
  _impl_.top_k_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ArgMaxParameter::_internal_top_k() const {
  return _impl_.top_k_;
}
inline uint32_t ArgMaxParameter::top_k() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.top_k)
  return _internal_top_k();
}
inline void ArgMaxParameter::_internal_set_top_k(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.top_k_ = value;
}
inline void ArgMaxParameter::set_top_k(uint32_t value) {
  _internal_set_top_k(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.top_k)
}

// optional int32 axis = 3;
inline bool ArgMaxParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ArgMaxParameter::has_axis() const {
  return _internal_has_axis();
}
inline void ArgMaxParameter::clear_axis() {
  _impl_.axis_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ArgMaxParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t ArgMaxParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ArgMaxParameter.axis)
  return _internal_axis();
}
inline void ArgMaxParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void ArgMaxParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ArgMaxParameter.axis)
}

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

// ConcatParameter

// optional int32 axis = 2 [default = 1];
inline bool ConcatParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ConcatParameter::has_axis() const {
  return _internal_has_axis();
}
inline void ConcatParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ConcatParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t ConcatParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConcatParameter.axis)
  return _internal_axis();
}
inline void ConcatParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void ConcatParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConcatParameter.axis)
}

// optional uint32 concat_dim = 1 [default = 1];
inline bool ConcatParameter::_internal_has_concat_dim() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ConcatParameter::has_concat_dim() const {
  return _internal_has_concat_dim();
}
inline void ConcatParameter::clear_concat_dim() {
  _impl_.concat_dim_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ConcatParameter::_internal_concat_dim() const {
  return _impl_.concat_dim_;
}
inline uint32_t ConcatParameter::concat_dim() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConcatParameter.concat_dim)
  return _internal_concat_dim();
}
inline void ConcatParameter::_internal_set_concat_dim(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.concat_dim_ = value;
}
inline void ConcatParameter::set_concat_dim(uint32_t value) {
  _internal_set_concat_dim(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConcatParameter.concat_dim)
}

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

// BatchNormParameter

// optional bool use_global_stats = 1;
inline bool BatchNormParameter::_internal_has_use_global_stats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BatchNormParameter::has_use_global_stats() const {
  return _internal_has_use_global_stats();
}
inline void BatchNormParameter::clear_use_global_stats() {
  _impl_.use_global_stats_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool BatchNormParameter::_internal_use_global_stats() const {
  return _impl_.use_global_stats_;
}
inline bool BatchNormParameter::use_global_stats() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.use_global_stats)
  return _internal_use_global_stats();
}
inline void BatchNormParameter::_internal_set_use_global_stats(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.use_global_stats_ = value;
}
inline void BatchNormParameter::set_use_global_stats(bool value) {
  _internal_set_use_global_stats(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.use_global_stats)
}

// optional float moving_average_fraction = 2 [default = 0.999];
inline bool BatchNormParameter::_internal_has_moving_average_fraction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BatchNormParameter::has_moving_average_fraction() const {
  return _internal_has_moving_average_fraction();
}
inline void BatchNormParameter::clear_moving_average_fraction() {
  _impl_.moving_average_fraction_ = 0.999f;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float BatchNormParameter::_internal_moving_average_fraction() const {
  return _impl_.moving_average_fraction_;
}
inline float BatchNormParameter::moving_average_fraction() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.moving_average_fraction)
  return _internal_moving_average_fraction();
}
inline void BatchNormParameter::_internal_set_moving_average_fraction(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.moving_average_fraction_ = value;
}
inline void BatchNormParameter::set_moving_average_fraction(float value) {
  _internal_set_moving_average_fraction(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.moving_average_fraction)
}

// optional float eps = 3 [default = 1e-05];
inline bool BatchNormParameter::_internal_has_eps() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool BatchNormParameter::has_eps() const {
  return _internal_has_eps();
}
inline void BatchNormParameter::clear_eps() {
  _impl_.eps_ = 1e-05f;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float BatchNormParameter::_internal_eps() const {
  return _impl_.eps_;
}
inline float BatchNormParameter::eps() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.eps)
  return _internal_eps();
}
inline void BatchNormParameter::_internal_set_eps(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.eps_ = value;
}
inline void BatchNormParameter::set_eps(float value) {
  _internal_set_eps(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.eps)
}

// optional bool scale_bias = 7 [default = false];
inline bool BatchNormParameter::_internal_has_scale_bias() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool BatchNormParameter::has_scale_bias() const {
  return _internal_has_scale_bias();
}
inline void BatchNormParameter::clear_scale_bias() {
  _impl_.scale_bias_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool BatchNormParameter::_internal_scale_bias() const {
  return _impl_.scale_bias_;
}
inline bool BatchNormParameter::scale_bias() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BatchNormParameter.scale_bias)
  return _internal_scale_bias();
}
inline void BatchNormParameter::_internal_set_scale_bias(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.scale_bias_ = value;
}
inline void BatchNormParameter::set_scale_bias(bool value) {
  _internal_set_scale_bias(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BatchNormParameter.scale_bias)
}

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

// BiasParameter

// optional int32 axis = 1 [default = 1];
inline bool BiasParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool BiasParameter::has_axis() const {
  return _internal_has_axis();
}
inline void BiasParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t BiasParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t BiasParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.axis)
  return _internal_axis();
}
inline void BiasParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void BiasParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BiasParameter.axis)
}

// optional int32 num_axes = 2 [default = 1];
inline bool BiasParameter::_internal_has_num_axes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BiasParameter::has_num_axes() const {
  return _internal_has_num_axes();
}
inline void BiasParameter::clear_num_axes() {
  _impl_.num_axes_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t BiasParameter::_internal_num_axes() const {
  return _impl_.num_axes_;
}
inline int32_t BiasParameter::num_axes() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.num_axes)
  return _internal_num_axes();
}
inline void BiasParameter::_internal_set_num_axes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_axes_ = value;
}
inline void BiasParameter::set_num_axes(int32_t value) {
  _internal_set_num_axes(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.BiasParameter.num_axes)
}

// optional .opencv_caffe.FillerParameter filler = 3;
inline bool BiasParameter::_internal_has_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.filler_ != nullptr);
  return value;
}
inline bool BiasParameter::has_filler() const {
  return _internal_has_filler();
}
inline void BiasParameter::clear_filler() {
  if (_impl_.filler_ != nullptr) _impl_.filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& BiasParameter::_internal_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& BiasParameter::filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.BiasParameter.filler)
  return _internal_filler();
}
inline void BiasParameter::unsafe_arena_set_allocated_filler(
    ::opencv_caffe::FillerParameter* filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.filler_);
  }
  _impl_.filler_ = filler;
  if (filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.BiasParameter.filler)
}
inline ::opencv_caffe::FillerParameter* BiasParameter::release_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.filler_;
  _impl_.filler_ = 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 ::opencv_caffe::FillerParameter* BiasParameter::unsafe_arena_release_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.BiasParameter.filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.filler_;
  _impl_.filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* BiasParameter::_internal_mutable_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.filler_ = p;
  }
  return _impl_.filler_;
}
inline ::opencv_caffe::FillerParameter* BiasParameter::mutable_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.BiasParameter.filler)
  return _msg;
}
inline void BiasParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.filler_;
  }
  if (filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(filler);
    if (message_arena != submessage_arena) {
      filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filler_ = filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.BiasParameter.filler)
}

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

// ContrastiveLossParameter

// optional float margin = 1 [default = 1];
inline bool ContrastiveLossParameter::_internal_has_margin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ContrastiveLossParameter::has_margin() const {
  return _internal_has_margin();
}
inline void ContrastiveLossParameter::clear_margin() {
  _impl_.margin_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float ContrastiveLossParameter::_internal_margin() const {
  return _impl_.margin_;
}
inline float ContrastiveLossParameter::margin() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ContrastiveLossParameter.margin)
  return _internal_margin();
}
inline void ContrastiveLossParameter::_internal_set_margin(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.margin_ = value;
}
inline void ContrastiveLossParameter::set_margin(float value) {
  _internal_set_margin(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ContrastiveLossParameter.margin)
}

// optional bool legacy_version = 2 [default = false];
inline bool ContrastiveLossParameter::_internal_has_legacy_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ContrastiveLossParameter::has_legacy_version() const {
  return _internal_has_legacy_version();
}
inline void ContrastiveLossParameter::clear_legacy_version() {
  _impl_.legacy_version_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool ContrastiveLossParameter::_internal_legacy_version() const {
  return _impl_.legacy_version_;
}
inline bool ContrastiveLossParameter::legacy_version() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ContrastiveLossParameter.legacy_version)
  return _internal_legacy_version();
}
inline void ContrastiveLossParameter::_internal_set_legacy_version(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.legacy_version_ = value;
}
inline void ContrastiveLossParameter::set_legacy_version(bool value) {
  _internal_set_legacy_version(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ContrastiveLossParameter.legacy_version)
}

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

// ConvolutionParameter

// optional uint32 num_output = 1;
inline bool ConvolutionParameter::_internal_has_num_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_num_output() const {
  return _internal_has_num_output();
}
inline void ConvolutionParameter::clear_num_output() {
  _impl_.num_output_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ConvolutionParameter::_internal_num_output() const {
  return _impl_.num_output_;
}
inline uint32_t ConvolutionParameter::num_output() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.num_output)
  return _internal_num_output();
}
inline void ConvolutionParameter::_internal_set_num_output(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_output_ = value;
}
inline void ConvolutionParameter::set_num_output(uint32_t value) {
  _internal_set_num_output(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.num_output)
}

// optional bool bias_term = 2 [default = true];
inline bool ConvolutionParameter::_internal_has_bias_term() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_bias_term() const {
  return _internal_has_bias_term();
}
inline void ConvolutionParameter::clear_bias_term() {
  _impl_.bias_term_ = true;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline bool ConvolutionParameter::_internal_bias_term() const {
  return _impl_.bias_term_;
}
inline bool ConvolutionParameter::bias_term() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.bias_term)
  return _internal_bias_term();
}
inline void ConvolutionParameter::_internal_set_bias_term(bool value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.bias_term_ = value;
}
inline void ConvolutionParameter::set_bias_term(bool value) {
  _internal_set_bias_term(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.bias_term)
}

// repeated uint32 pad = 3;
inline int ConvolutionParameter::_internal_pad_size() const {
  return _impl_.pad_.size();
}
inline int ConvolutionParameter::pad_size() const {
  return _internal_pad_size();
}
inline void ConvolutionParameter::clear_pad() {
  _impl_.pad_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_pad(int index) const {
  return _impl_.pad_.Get(index);
}
inline uint32_t ConvolutionParameter::pad(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad)
  return _internal_pad(index);
}
inline void ConvolutionParameter::set_pad(int index, uint32_t value) {
  _impl_.pad_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad)
}
inline void ConvolutionParameter::_internal_add_pad(uint32_t value) {
  _impl_.pad_.Add(value);
}
inline void ConvolutionParameter::add_pad(uint32_t value) {
  _internal_add_pad(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.pad)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_pad() const {
  return _impl_.pad_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::pad() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.pad)
  return _internal_pad();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_pad() {
  return &_impl_.pad_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_pad() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.pad)
  return _internal_mutable_pad();
}

// repeated uint32 kernel_size = 4;
inline int ConvolutionParameter::_internal_kernel_size_size() const {
  return _impl_.kernel_size_.size();
}
inline int ConvolutionParameter::kernel_size_size() const {
  return _internal_kernel_size_size();
}
inline void ConvolutionParameter::clear_kernel_size() {
  _impl_.kernel_size_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_kernel_size(int index) const {
  return _impl_.kernel_size_.Get(index);
}
inline uint32_t ConvolutionParameter::kernel_size(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_size)
  return _internal_kernel_size(index);
}
inline void ConvolutionParameter::set_kernel_size(int index, uint32_t value) {
  _impl_.kernel_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_size)
}
inline void ConvolutionParameter::_internal_add_kernel_size(uint32_t value) {
  _impl_.kernel_size_.Add(value);
}
inline void ConvolutionParameter::add_kernel_size(uint32_t value) {
  _internal_add_kernel_size(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.kernel_size)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_kernel_size() const {
  return _impl_.kernel_size_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::kernel_size() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.kernel_size)
  return _internal_kernel_size();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_kernel_size() {
  return &_impl_.kernel_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_kernel_size() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.kernel_size)
  return _internal_mutable_kernel_size();
}

// repeated uint32 stride = 6;
inline int ConvolutionParameter::_internal_stride_size() const {
  return _impl_.stride_.size();
}
inline int ConvolutionParameter::stride_size() const {
  return _internal_stride_size();
}
inline void ConvolutionParameter::clear_stride() {
  _impl_.stride_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_stride(int index) const {
  return _impl_.stride_.Get(index);
}
inline uint32_t ConvolutionParameter::stride(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride)
  return _internal_stride(index);
}
inline void ConvolutionParameter::set_stride(int index, uint32_t value) {
  _impl_.stride_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride)
}
inline void ConvolutionParameter::_internal_add_stride(uint32_t value) {
  _impl_.stride_.Add(value);
}
inline void ConvolutionParameter::add_stride(uint32_t value) {
  _internal_add_stride(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.stride)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_stride() const {
  return _impl_.stride_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::stride() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.stride)
  return _internal_stride();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_stride() {
  return &_impl_.stride_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_stride() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.stride)
  return _internal_mutable_stride();
}

// repeated uint32 dilation = 18;
inline int ConvolutionParameter::_internal_dilation_size() const {
  return _impl_.dilation_.size();
}
inline int ConvolutionParameter::dilation_size() const {
  return _internal_dilation_size();
}
inline void ConvolutionParameter::clear_dilation() {
  _impl_.dilation_.Clear();
}
inline uint32_t ConvolutionParameter::_internal_dilation(int index) const {
  return _impl_.dilation_.Get(index);
}
inline uint32_t ConvolutionParameter::dilation(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.dilation)
  return _internal_dilation(index);
}
inline void ConvolutionParameter::set_dilation(int index, uint32_t value) {
  _impl_.dilation_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.dilation)
}
inline void ConvolutionParameter::_internal_add_dilation(uint32_t value) {
  _impl_.dilation_.Add(value);
}
inline void ConvolutionParameter::add_dilation(uint32_t value) {
  _internal_add_dilation(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.ConvolutionParameter.dilation)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::_internal_dilation() const {
  return _impl_.dilation_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ConvolutionParameter::dilation() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.ConvolutionParameter.dilation)
  return _internal_dilation();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::_internal_mutable_dilation() {
  return &_impl_.dilation_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ConvolutionParameter::mutable_dilation() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ConvolutionParameter.dilation)
  return _internal_mutable_dilation();
}

// optional uint32 pad_h = 9 [default = 0];
inline bool ConvolutionParameter::_internal_has_pad_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_pad_h() const {
  return _internal_has_pad_h();
}
inline void ConvolutionParameter::clear_pad_h() {
  _impl_.pad_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ConvolutionParameter::_internal_pad_h() const {
  return _impl_.pad_h_;
}
inline uint32_t ConvolutionParameter::pad_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad_h)
  return _internal_pad_h();
}
inline void ConvolutionParameter::_internal_set_pad_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.pad_h_ = value;
}
inline void ConvolutionParameter::set_pad_h(uint32_t value) {
  _internal_set_pad_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad_h)
}

// optional uint32 pad_w = 10 [default = 0];
inline bool ConvolutionParameter::_internal_has_pad_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_pad_w() const {
  return _internal_has_pad_w();
}
inline void ConvolutionParameter::clear_pad_w() {
  _impl_.pad_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ConvolutionParameter::_internal_pad_w() const {
  return _impl_.pad_w_;
}
inline uint32_t ConvolutionParameter::pad_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.pad_w)
  return _internal_pad_w();
}
inline void ConvolutionParameter::_internal_set_pad_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.pad_w_ = value;
}
inline void ConvolutionParameter::set_pad_w(uint32_t value) {
  _internal_set_pad_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.pad_w)
}

// optional uint32 kernel_h = 11;
inline bool ConvolutionParameter::_internal_has_kernel_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_kernel_h() const {
  return _internal_has_kernel_h();
}
inline void ConvolutionParameter::clear_kernel_h() {
  _impl_.kernel_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t ConvolutionParameter::_internal_kernel_h() const {
  return _impl_.kernel_h_;
}
inline uint32_t ConvolutionParameter::kernel_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_h)
  return _internal_kernel_h();
}
inline void ConvolutionParameter::_internal_set_kernel_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.kernel_h_ = value;
}
inline void ConvolutionParameter::set_kernel_h(uint32_t value) {
  _internal_set_kernel_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_h)
}

// optional uint32 kernel_w = 12;
inline bool ConvolutionParameter::_internal_has_kernel_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_kernel_w() const {
  return _internal_has_kernel_w();
}
inline void ConvolutionParameter::clear_kernel_w() {
  _impl_.kernel_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t ConvolutionParameter::_internal_kernel_w() const {
  return _impl_.kernel_w_;
}
inline uint32_t ConvolutionParameter::kernel_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.kernel_w)
  return _internal_kernel_w();
}
inline void ConvolutionParameter::_internal_set_kernel_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.kernel_w_ = value;
}
inline void ConvolutionParameter::set_kernel_w(uint32_t value) {
  _internal_set_kernel_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.kernel_w)
}

// optional uint32 stride_h = 13;
inline bool ConvolutionParameter::_internal_has_stride_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_stride_h() const {
  return _internal_has_stride_h();
}
inline void ConvolutionParameter::clear_stride_h() {
  _impl_.stride_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t ConvolutionParameter::_internal_stride_h() const {
  return _impl_.stride_h_;
}
inline uint32_t ConvolutionParameter::stride_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride_h)
  return _internal_stride_h();
}
inline void ConvolutionParameter::_internal_set_stride_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.stride_h_ = value;
}
inline void ConvolutionParameter::set_stride_h(uint32_t value) {
  _internal_set_stride_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride_h)
}

// optional uint32 stride_w = 14;
inline bool ConvolutionParameter::_internal_has_stride_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_stride_w() const {
  return _internal_has_stride_w();
}
inline void ConvolutionParameter::clear_stride_w() {
  _impl_.stride_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t ConvolutionParameter::_internal_stride_w() const {
  return _impl_.stride_w_;
}
inline uint32_t ConvolutionParameter::stride_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.stride_w)
  return _internal_stride_w();
}
inline void ConvolutionParameter::_internal_set_stride_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.stride_w_ = value;
}
inline void ConvolutionParameter::set_stride_w(uint32_t value) {
  _internal_set_stride_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.stride_w)
}

// optional uint32 group = 5 [default = 1];
inline bool ConvolutionParameter::_internal_has_group() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_group() const {
  return _internal_has_group();
}
inline void ConvolutionParameter::clear_group() {
  _impl_.group_ = 1u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t ConvolutionParameter::_internal_group() const {
  return _impl_.group_;
}
inline uint32_t ConvolutionParameter::group() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.group)
  return _internal_group();
}
inline void ConvolutionParameter::_internal_set_group(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.group_ = value;
}
inline void ConvolutionParameter::set_group(uint32_t value) {
  _internal_set_group(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.group)
}

// optional .opencv_caffe.FillerParameter weight_filler = 7;
inline bool ConvolutionParameter::_internal_has_weight_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.weight_filler_ != nullptr);
  return value;
}
inline bool ConvolutionParameter::has_weight_filler() const {
  return _internal_has_weight_filler();
}
inline void ConvolutionParameter::clear_weight_filler() {
  if (_impl_.weight_filler_ != nullptr) _impl_.weight_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::_internal_weight_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.weight_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::weight_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.weight_filler)
  return _internal_weight_filler();
}
inline void ConvolutionParameter::unsafe_arena_set_allocated_weight_filler(
    ::opencv_caffe::FillerParameter* weight_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.weight_filler_);
  }
  _impl_.weight_filler_ = weight_filler;
  if (weight_filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ConvolutionParameter.weight_filler)
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::release_weight_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = 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 ::opencv_caffe::FillerParameter* ConvolutionParameter::unsafe_arena_release_weight_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ConvolutionParameter.weight_filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::_internal_mutable_weight_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.weight_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.weight_filler_ = p;
  }
  return _impl_.weight_filler_;
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ConvolutionParameter.weight_filler)
  return _msg;
}
inline void ConvolutionParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.weight_filler_;
  }
  if (weight_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(weight_filler);
    if (message_arena != submessage_arena) {
      weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, weight_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.weight_filler_ = weight_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ConvolutionParameter.weight_filler)
}

// optional .opencv_caffe.FillerParameter bias_filler = 8;
inline bool ConvolutionParameter::_internal_has_bias_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_filler_ != nullptr);
  return value;
}
inline bool ConvolutionParameter::has_bias_filler() const {
  return _internal_has_bias_filler();
}
inline void ConvolutionParameter::clear_bias_filler() {
  if (_impl_.bias_filler_ != nullptr) _impl_.bias_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::_internal_bias_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.bias_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& ConvolutionParameter::bias_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.bias_filler)
  return _internal_bias_filler();
}
inline void ConvolutionParameter::unsafe_arena_set_allocated_bias_filler(
    ::opencv_caffe::FillerParameter* bias_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_filler_);
  }
  _impl_.bias_filler_ = bias_filler;
  if (bias_filler) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ConvolutionParameter.bias_filler)
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::release_bias_filler() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = 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 ::opencv_caffe::FillerParameter* ConvolutionParameter::unsafe_arena_release_bias_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ConvolutionParameter.bias_filler)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::_internal_mutable_bias_filler() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.bias_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.bias_filler_ = p;
  }
  return _impl_.bias_filler_;
}
inline ::opencv_caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ConvolutionParameter.bias_filler)
  return _msg;
}
inline void ConvolutionParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_filler_;
  }
  if (bias_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_filler);
    if (message_arena != submessage_arena) {
      bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.bias_filler_ = bias_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ConvolutionParameter.bias_filler)
}

// optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
inline bool ConvolutionParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_engine() const {
  return _internal_has_engine();
}
inline void ConvolutionParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::opencv_caffe::ConvolutionParameter_Engine ConvolutionParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::ConvolutionParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.engine)
  return _internal_engine();
}
inline void ConvolutionParameter::_internal_set_engine(::opencv_caffe::ConvolutionParameter_Engine value) {
  assert(::opencv_caffe::ConvolutionParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.engine_ = value;
}
inline void ConvolutionParameter::set_engine(::opencv_caffe::ConvolutionParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.engine)
}

// optional int32 axis = 16 [default = 1];
inline bool ConvolutionParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_axis() const {
  return _internal_has_axis();
}
inline void ConvolutionParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t ConvolutionParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t ConvolutionParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.axis)
  return _internal_axis();
}
inline void ConvolutionParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.axis_ = value;
}
inline void ConvolutionParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.axis)
}

// optional bool force_nd_im2col = 17 [default = false];
inline bool ConvolutionParameter::_internal_has_force_nd_im2col() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ConvolutionParameter::has_force_nd_im2col() const {
  return _internal_has_force_nd_im2col();
}
inline void ConvolutionParameter::clear_force_nd_im2col() {
  _impl_.force_nd_im2col_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool ConvolutionParameter::_internal_force_nd_im2col() const {
  return _impl_.force_nd_im2col_;
}
inline bool ConvolutionParameter::force_nd_im2col() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ConvolutionParameter.force_nd_im2col)
  return _internal_force_nd_im2col();
}
inline void ConvolutionParameter::_internal_set_force_nd_im2col(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.force_nd_im2col_ = value;
}
inline void ConvolutionParameter::set_force_nd_im2col(bool value) {
  _internal_set_force_nd_im2col(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ConvolutionParameter.force_nd_im2col)
}

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

// CropParameter

// optional int32 axis = 1 [default = 2];
inline bool CropParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CropParameter::has_axis() const {
  return _internal_has_axis();
}
inline void CropParameter::clear_axis() {
  _impl_.axis_ = 2;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CropParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t CropParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.CropParameter.axis)
  return _internal_axis();
}
inline void CropParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.axis_ = value;
}
inline void CropParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.CropParameter.axis)
}

// repeated uint32 offset = 2;
inline int CropParameter::_internal_offset_size() const {
  return _impl_.offset_.size();
}
inline int CropParameter::offset_size() const {
  return _internal_offset_size();
}
inline void CropParameter::clear_offset() {
  _impl_.offset_.Clear();
}
inline uint32_t CropParameter::_internal_offset(int index) const {
  return _impl_.offset_.Get(index);
}
inline uint32_t CropParameter::offset(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.CropParameter.offset)
  return _internal_offset(index);
}
inline void CropParameter::set_offset(int index, uint32_t value) {
  _impl_.offset_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.CropParameter.offset)
}
inline void CropParameter::_internal_add_offset(uint32_t value) {
  _impl_.offset_.Add(value);
}
inline void CropParameter::add_offset(uint32_t value) {
  _internal_add_offset(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.CropParameter.offset)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CropParameter::_internal_offset() const {
  return _impl_.offset_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CropParameter::offset() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.CropParameter.offset)
  return _internal_offset();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CropParameter::_internal_mutable_offset() {
  return &_impl_.offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CropParameter::mutable_offset() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.CropParameter.offset)
  return _internal_mutable_offset();
}

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

// DataParameter

// optional string source = 1;
inline bool DataParameter::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DataParameter::has_source() const {
  return _internal_has_source();
}
inline void DataParameter::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DataParameter::source() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataParameter::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.source)
}
inline std::string* DataParameter::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.DataParameter.source)
  return _s;
}
inline const std::string& DataParameter::_internal_source() const {
  return _impl_.source_.Get();
}
inline void DataParameter::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* DataParameter::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* DataParameter::release_source() {
  // @@protoc_insertion_point(field_release:opencv_caffe.DataParameter.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataParameter::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.DataParameter.source)
}

// optional uint32 batch_size = 4;
inline bool DataParameter::_internal_has_batch_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DataParameter::has_batch_size() const {
  return _internal_has_batch_size();
}
inline void DataParameter::clear_batch_size() {
  _impl_.batch_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t DataParameter::_internal_batch_size() const {
  return _impl_.batch_size_;
}
inline uint32_t DataParameter::batch_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.batch_size)
  return _internal_batch_size();
}
inline void DataParameter::_internal_set_batch_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.batch_size_ = value;
}
inline void DataParameter::set_batch_size(uint32_t value) {
  _internal_set_batch_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.batch_size)
}

// optional uint32 rand_skip = 7 [default = 0];
inline bool DataParameter::_internal_has_rand_skip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DataParameter::has_rand_skip() const {
  return _internal_has_rand_skip();
}
inline void DataParameter::clear_rand_skip() {
  _impl_.rand_skip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t DataParameter::_internal_rand_skip() const {
  return _impl_.rand_skip_;
}
inline uint32_t DataParameter::rand_skip() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.rand_skip)
  return _internal_rand_skip();
}
inline void DataParameter::_internal_set_rand_skip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.rand_skip_ = value;
}
inline void DataParameter::set_rand_skip(uint32_t value) {
  _internal_set_rand_skip(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.rand_skip)
}

// optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
inline bool DataParameter::_internal_has_backend() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool DataParameter::has_backend() const {
  return _internal_has_backend();
}
inline void DataParameter::clear_backend() {
  _impl_.backend_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::opencv_caffe::DataParameter_DB DataParameter::_internal_backend() const {
  return static_cast< ::opencv_caffe::DataParameter_DB >(_impl_.backend_);
}
inline ::opencv_caffe::DataParameter_DB DataParameter::backend() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.backend)
  return _internal_backend();
}
inline void DataParameter::_internal_set_backend(::opencv_caffe::DataParameter_DB value) {
  assert(::opencv_caffe::DataParameter_DB_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.backend_ = value;
}
inline void DataParameter::set_backend(::opencv_caffe::DataParameter_DB value) {
  _internal_set_backend(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.backend)
}

// optional float scale = 2 [default = 1];
inline bool DataParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool DataParameter::has_scale() const {
  return _internal_has_scale();
}
inline void DataParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float DataParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float DataParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.scale)
  return _internal_scale();
}
inline void DataParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.scale_ = value;
}
inline void DataParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.scale)
}

// optional string mean_file = 3;
inline bool DataParameter::_internal_has_mean_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DataParameter::has_mean_file() const {
  return _internal_has_mean_file();
}
inline void DataParameter::clear_mean_file() {
  _impl_.mean_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DataParameter::mean_file() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.mean_file)
  return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mean_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.mean_file)
}
inline std::string* DataParameter::mutable_mean_file() {
  std::string* _s = _internal_mutable_mean_file();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.DataParameter.mean_file)
  return _s;
}
inline const std::string& DataParameter::_internal_mean_file() const {
  return _impl_.mean_file_.Get();
}
inline void DataParameter::_internal_set_mean_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mean_file_.Set(value, GetArenaForAllocation());
}
inline std::string* DataParameter::_internal_mutable_mean_file() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mean_file_.Mutable(GetArenaForAllocation());
}
inline std::string* DataParameter::release_mean_file() {
  // @@protoc_insertion_point(field_release:opencv_caffe.DataParameter.mean_file)
  if (!_internal_has_mean_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mean_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DataParameter::set_allocated_mean_file(std::string* mean_file) {
  if (mean_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mean_file_.SetAllocated(mean_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.DataParameter.mean_file)
}

// optional uint32 crop_size = 5 [default = 0];
inline bool DataParameter::_internal_has_crop_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DataParameter::has_crop_size() const {
  return _internal_has_crop_size();
}
inline void DataParameter::clear_crop_size() {
  _impl_.crop_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t DataParameter::_internal_crop_size() const {
  return _impl_.crop_size_;
}
inline uint32_t DataParameter::crop_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.crop_size)
  return _internal_crop_size();
}
inline void DataParameter::_internal_set_crop_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.crop_size_ = value;
}
inline void DataParameter::set_crop_size(uint32_t value) {
  _internal_set_crop_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.crop_size)
}

// optional bool mirror = 6 [default = false];
inline bool DataParameter::_internal_has_mirror() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool DataParameter::has_mirror() const {
  return _internal_has_mirror();
}
inline void DataParameter::clear_mirror() {
  _impl_.mirror_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool DataParameter::_internal_mirror() const {
  return _impl_.mirror_;
}
inline bool DataParameter::mirror() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.mirror)
  return _internal_mirror();
}
inline void DataParameter::_internal_set_mirror(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.mirror_ = value;
}
inline void DataParameter::set_mirror(bool value) {
  _internal_set_mirror(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.mirror)
}

// optional bool force_encoded_color = 9 [default = false];
inline bool DataParameter::_internal_has_force_encoded_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool DataParameter::has_force_encoded_color() const {
  return _internal_has_force_encoded_color();
}
inline void DataParameter::clear_force_encoded_color() {
  _impl_.force_encoded_color_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool DataParameter::_internal_force_encoded_color() const {
  return _impl_.force_encoded_color_;
}
inline bool DataParameter::force_encoded_color() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.force_encoded_color)
  return _internal_force_encoded_color();
}
inline void DataParameter::_internal_set_force_encoded_color(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.force_encoded_color_ = value;
}
inline void DataParameter::set_force_encoded_color(bool value) {
  _internal_set_force_encoded_color(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.force_encoded_color)
}

// optional uint32 prefetch = 10 [default = 4];
inline bool DataParameter::_internal_has_prefetch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool DataParameter::has_prefetch() const {
  return _internal_has_prefetch();
}
inline void DataParameter::clear_prefetch() {
  _impl_.prefetch_ = 4u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t DataParameter::_internal_prefetch() const {
  return _impl_.prefetch_;
}
inline uint32_t DataParameter::prefetch() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DataParameter.prefetch)
  return _internal_prefetch();
}
inline void DataParameter::_internal_set_prefetch(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.prefetch_ = value;
}
inline void DataParameter::set_prefetch(uint32_t value) {
  _internal_set_prefetch(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DataParameter.prefetch)
}

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

// NonMaximumSuppressionParameter

// optional float nms_threshold = 1 [default = 0.3];
inline bool NonMaximumSuppressionParameter::_internal_has_nms_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NonMaximumSuppressionParameter::has_nms_threshold() const {
  return _internal_has_nms_threshold();
}
inline void NonMaximumSuppressionParameter::clear_nms_threshold() {
  _impl_.nms_threshold_ = 0.3f;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float NonMaximumSuppressionParameter::_internal_nms_threshold() const {
  return _impl_.nms_threshold_;
}
inline float NonMaximumSuppressionParameter::nms_threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.nms_threshold)
  return _internal_nms_threshold();
}
inline void NonMaximumSuppressionParameter::_internal_set_nms_threshold(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.nms_threshold_ = value;
}
inline void NonMaximumSuppressionParameter::set_nms_threshold(float value) {
  _internal_set_nms_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.nms_threshold)
}

// optional int32 top_k = 2;
inline bool NonMaximumSuppressionParameter::_internal_has_top_k() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NonMaximumSuppressionParameter::has_top_k() const {
  return _internal_has_top_k();
}
inline void NonMaximumSuppressionParameter::clear_top_k() {
  _impl_.top_k_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t NonMaximumSuppressionParameter::_internal_top_k() const {
  return _impl_.top_k_;
}
inline int32_t NonMaximumSuppressionParameter::top_k() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.top_k)
  return _internal_top_k();
}
inline void NonMaximumSuppressionParameter::_internal_set_top_k(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.top_k_ = value;
}
inline void NonMaximumSuppressionParameter::set_top_k(int32_t value) {
  _internal_set_top_k(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.top_k)
}

// optional float eta = 3 [default = 1];
inline bool NonMaximumSuppressionParameter::_internal_has_eta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NonMaximumSuppressionParameter::has_eta() const {
  return _internal_has_eta();
}
inline void NonMaximumSuppressionParameter::clear_eta() {
  _impl_.eta_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float NonMaximumSuppressionParameter::_internal_eta() const {
  return _impl_.eta_;
}
inline float NonMaximumSuppressionParameter::eta() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NonMaximumSuppressionParameter.eta)
  return _internal_eta();
}
inline void NonMaximumSuppressionParameter::_internal_set_eta(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.eta_ = value;
}
inline void NonMaximumSuppressionParameter::set_eta(float value) {
  _internal_set_eta(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NonMaximumSuppressionParameter.eta)
}

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

// SaveOutputParameter

// optional string output_directory = 1;
inline bool SaveOutputParameter::_internal_has_output_directory() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SaveOutputParameter::has_output_directory() const {
  return _internal_has_output_directory();
}
inline void SaveOutputParameter::clear_output_directory() {
  _impl_.output_directory_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SaveOutputParameter::output_directory() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_directory)
  return _internal_output_directory();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_output_directory(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.output_directory_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_directory)
}
inline std::string* SaveOutputParameter::mutable_output_directory() {
  std::string* _s = _internal_mutable_output_directory();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_directory)
  return _s;
}
inline const std::string& SaveOutputParameter::_internal_output_directory() const {
  return _impl_.output_directory_.Get();
}
inline void SaveOutputParameter::_internal_set_output_directory(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.output_directory_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_output_directory() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.output_directory_.Mutable(GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_output_directory() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_directory)
  if (!_internal_has_output_directory()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.output_directory_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_directory_.IsDefault()) {
    _impl_.output_directory_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SaveOutputParameter::set_allocated_output_directory(std::string* output_directory) {
  if (output_directory != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.output_directory_.SetAllocated(output_directory, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_directory_.IsDefault()) {
    _impl_.output_directory_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_directory)
}

// optional string output_name_prefix = 2;
inline bool SaveOutputParameter::_internal_has_output_name_prefix() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SaveOutputParameter::has_output_name_prefix() const {
  return _internal_has_output_name_prefix();
}
inline void SaveOutputParameter::clear_output_name_prefix() {
  _impl_.output_name_prefix_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SaveOutputParameter::output_name_prefix() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_name_prefix)
  return _internal_output_name_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_output_name_prefix(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.output_name_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_name_prefix)
}
inline std::string* SaveOutputParameter::mutable_output_name_prefix() {
  std::string* _s = _internal_mutable_output_name_prefix();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_name_prefix)
  return _s;
}
inline const std::string& SaveOutputParameter::_internal_output_name_prefix() const {
  return _impl_.output_name_prefix_.Get();
}
inline void SaveOutputParameter::_internal_set_output_name_prefix(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.output_name_prefix_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_output_name_prefix() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.output_name_prefix_.Mutable(GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_output_name_prefix() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_name_prefix)
  if (!_internal_has_output_name_prefix()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.output_name_prefix_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_name_prefix_.IsDefault()) {
    _impl_.output_name_prefix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SaveOutputParameter::set_allocated_output_name_prefix(std::string* output_name_prefix) {
  if (output_name_prefix != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.output_name_prefix_.SetAllocated(output_name_prefix, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_name_prefix_.IsDefault()) {
    _impl_.output_name_prefix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_name_prefix)
}

// optional string output_format = 3;
inline bool SaveOutputParameter::_internal_has_output_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SaveOutputParameter::has_output_format() const {
  return _internal_has_output_format();
}
inline void SaveOutputParameter::clear_output_format() {
  _impl_.output_format_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SaveOutputParameter::output_format() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.output_format)
  return _internal_output_format();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_output_format(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.output_format_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.output_format)
}
inline std::string* SaveOutputParameter::mutable_output_format() {
  std::string* _s = _internal_mutable_output_format();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.output_format)
  return _s;
}
inline const std::string& SaveOutputParameter::_internal_output_format() const {
  return _impl_.output_format_.Get();
}
inline void SaveOutputParameter::_internal_set_output_format(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.output_format_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_output_format() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.output_format_.Mutable(GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_output_format() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.output_format)
  if (!_internal_has_output_format()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.output_format_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_format_.IsDefault()) {
    _impl_.output_format_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SaveOutputParameter::set_allocated_output_format(std::string* output_format) {
  if (output_format != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.output_format_.SetAllocated(output_format, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_format_.IsDefault()) {
    _impl_.output_format_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.output_format)
}

// optional string label_map_file = 4;
inline bool SaveOutputParameter::_internal_has_label_map_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SaveOutputParameter::has_label_map_file() const {
  return _internal_has_label_map_file();
}
inline void SaveOutputParameter::clear_label_map_file() {
  _impl_.label_map_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SaveOutputParameter::label_map_file() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.label_map_file)
  return _internal_label_map_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_label_map_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.label_map_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.label_map_file)
}
inline std::string* SaveOutputParameter::mutable_label_map_file() {
  std::string* _s = _internal_mutable_label_map_file();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.label_map_file)
  return _s;
}
inline const std::string& SaveOutputParameter::_internal_label_map_file() const {
  return _impl_.label_map_file_.Get();
}
inline void SaveOutputParameter::_internal_set_label_map_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.label_map_file_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_label_map_file() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.label_map_file_.Mutable(GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_label_map_file() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.label_map_file)
  if (!_internal_has_label_map_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.label_map_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.label_map_file_.IsDefault()) {
    _impl_.label_map_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SaveOutputParameter::set_allocated_label_map_file(std::string* label_map_file) {
  if (label_map_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.label_map_file_.SetAllocated(label_map_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.label_map_file_.IsDefault()) {
    _impl_.label_map_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.label_map_file)
}

// optional string name_size_file = 5;
inline bool SaveOutputParameter::_internal_has_name_size_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SaveOutputParameter::has_name_size_file() const {
  return _internal_has_name_size_file();
}
inline void SaveOutputParameter::clear_name_size_file() {
  _impl_.name_size_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SaveOutputParameter::name_size_file() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.name_size_file)
  return _internal_name_size_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SaveOutputParameter::set_name_size_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.name_size_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.name_size_file)
}
inline std::string* SaveOutputParameter::mutable_name_size_file() {
  std::string* _s = _internal_mutable_name_size_file();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.SaveOutputParameter.name_size_file)
  return _s;
}
inline const std::string& SaveOutputParameter::_internal_name_size_file() const {
  return _impl_.name_size_file_.Get();
}
inline void SaveOutputParameter::_internal_set_name_size_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.name_size_file_.Set(value, GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::_internal_mutable_name_size_file() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.name_size_file_.Mutable(GetArenaForAllocation());
}
inline std::string* SaveOutputParameter::release_name_size_file() {
  // @@protoc_insertion_point(field_release:opencv_caffe.SaveOutputParameter.name_size_file)
  if (!_internal_has_name_size_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.name_size_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_size_file_.IsDefault()) {
    _impl_.name_size_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SaveOutputParameter::set_allocated_name_size_file(std::string* name_size_file) {
  if (name_size_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.name_size_file_.SetAllocated(name_size_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_size_file_.IsDefault()) {
    _impl_.name_size_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.SaveOutputParameter.name_size_file)
}

// optional uint32 num_test_image = 6;
inline bool SaveOutputParameter::_internal_has_num_test_image() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SaveOutputParameter::has_num_test_image() const {
  return _internal_has_num_test_image();
}
inline void SaveOutputParameter::clear_num_test_image() {
  _impl_.num_test_image_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t SaveOutputParameter::_internal_num_test_image() const {
  return _impl_.num_test_image_;
}
inline uint32_t SaveOutputParameter::num_test_image() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SaveOutputParameter.num_test_image)
  return _internal_num_test_image();
}
inline void SaveOutputParameter::_internal_set_num_test_image(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.num_test_image_ = value;
}
inline void SaveOutputParameter::set_num_test_image(uint32_t value) {
  _internal_set_num_test_image(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SaveOutputParameter.num_test_image)
}

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

// DropoutParameter

// optional float dropout_ratio = 1 [default = 0.5];
inline bool DropoutParameter::_internal_has_dropout_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DropoutParameter::has_dropout_ratio() const {
  return _internal_has_dropout_ratio();
}
inline void DropoutParameter::clear_dropout_ratio() {
  _impl_.dropout_ratio_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float DropoutParameter::_internal_dropout_ratio() const {
  return _impl_.dropout_ratio_;
}
inline float DropoutParameter::dropout_ratio() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DropoutParameter.dropout_ratio)
  return _internal_dropout_ratio();
}
inline void DropoutParameter::_internal_set_dropout_ratio(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dropout_ratio_ = value;
}
inline void DropoutParameter::set_dropout_ratio(float value) {
  _internal_set_dropout_ratio(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DropoutParameter.dropout_ratio)
}

// optional bool scale_train = 2 [default = true];
inline bool DropoutParameter::_internal_has_scale_train() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DropoutParameter::has_scale_train() const {
  return _internal_has_scale_train();
}
inline void DropoutParameter::clear_scale_train() {
  _impl_.scale_train_ = true;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool DropoutParameter::_internal_scale_train() const {
  return _impl_.scale_train_;
}
inline bool DropoutParameter::scale_train() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DropoutParameter.scale_train)
  return _internal_scale_train();
}
inline void DropoutParameter::_internal_set_scale_train(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.scale_train_ = value;
}
inline void DropoutParameter::set_scale_train(bool value) {
  _internal_set_scale_train(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DropoutParameter.scale_train)
}

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

// DummyDataParameter

// repeated .opencv_caffe.FillerParameter data_filler = 1;
inline int DummyDataParameter::_internal_data_filler_size() const {
  return _impl_.data_filler_.size();
}
inline int DummyDataParameter::data_filler_size() const {
  return _internal_data_filler_size();
}
inline void DummyDataParameter::clear_data_filler() {
  _impl_.data_filler_.Clear();
}
inline ::opencv_caffe::FillerParameter* DummyDataParameter::mutable_data_filler(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.DummyDataParameter.data_filler)
  return _impl_.data_filler_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >*
DummyDataParameter::mutable_data_filler() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.data_filler)
  return &_impl_.data_filler_;
}
inline const ::opencv_caffe::FillerParameter& DummyDataParameter::_internal_data_filler(int index) const {
  return _impl_.data_filler_.Get(index);
}
inline const ::opencv_caffe::FillerParameter& DummyDataParameter::data_filler(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.data_filler)
  return _internal_data_filler(index);
}
inline ::opencv_caffe::FillerParameter* DummyDataParameter::_internal_add_data_filler() {
  return _impl_.data_filler_.Add();
}
inline ::opencv_caffe::FillerParameter* DummyDataParameter::add_data_filler() {
  ::opencv_caffe::FillerParameter* _add = _internal_add_data_filler();
  // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.data_filler)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::FillerParameter >&
DummyDataParameter::data_filler() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.data_filler)
  return _impl_.data_filler_;
}

// repeated .opencv_caffe.BlobShape shape = 6;
inline int DummyDataParameter::_internal_shape_size() const {
  return _impl_.shape_.size();
}
inline int DummyDataParameter::shape_size() const {
  return _internal_shape_size();
}
inline void DummyDataParameter::clear_shape() {
  _impl_.shape_.Clear();
}
inline ::opencv_caffe::BlobShape* DummyDataParameter::mutable_shape(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.DummyDataParameter.shape)
  return _impl_.shape_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >*
DummyDataParameter::mutable_shape() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.shape)
  return &_impl_.shape_;
}
inline const ::opencv_caffe::BlobShape& DummyDataParameter::_internal_shape(int index) const {
  return _impl_.shape_.Get(index);
}
inline const ::opencv_caffe::BlobShape& DummyDataParameter::shape(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.shape)
  return _internal_shape(index);
}
inline ::opencv_caffe::BlobShape* DummyDataParameter::_internal_add_shape() {
  return _impl_.shape_.Add();
}
inline ::opencv_caffe::BlobShape* DummyDataParameter::add_shape() {
  ::opencv_caffe::BlobShape* _add = _internal_add_shape();
  // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.shape)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >&
DummyDataParameter::shape() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.shape)
  return _impl_.shape_;
}

// repeated uint32 num = 2;
inline int DummyDataParameter::_internal_num_size() const {
  return _impl_.num_.size();
}
inline int DummyDataParameter::num_size() const {
  return _internal_num_size();
}
inline void DummyDataParameter::clear_num() {
  _impl_.num_.Clear();
}
inline uint32_t DummyDataParameter::_internal_num(int index) const {
  return _impl_.num_.Get(index);
}
inline uint32_t DummyDataParameter::num(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.num)
  return _internal_num(index);
}
inline void DummyDataParameter::set_num(int index, uint32_t value) {
  _impl_.num_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.num)
}
inline void DummyDataParameter::_internal_add_num(uint32_t value) {
  _impl_.num_.Add(value);
}
inline void DummyDataParameter::add_num(uint32_t value) {
  _internal_add_num(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.num)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_num() const {
  return _impl_.num_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::num() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.num)
  return _internal_num();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_num() {
  return &_impl_.num_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_num() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.num)
  return _internal_mutable_num();
}

// repeated uint32 channels = 3;
inline int DummyDataParameter::_internal_channels_size() const {
  return _impl_.channels_.size();
}
inline int DummyDataParameter::channels_size() const {
  return _internal_channels_size();
}
inline void DummyDataParameter::clear_channels() {
  _impl_.channels_.Clear();
}
inline uint32_t DummyDataParameter::_internal_channels(int index) const {
  return _impl_.channels_.Get(index);
}
inline uint32_t DummyDataParameter::channels(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.channels)
  return _internal_channels(index);
}
inline void DummyDataParameter::set_channels(int index, uint32_t value) {
  _impl_.channels_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.channels)
}
inline void DummyDataParameter::_internal_add_channels(uint32_t value) {
  _impl_.channels_.Add(value);
}
inline void DummyDataParameter::add_channels(uint32_t value) {
  _internal_add_channels(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.channels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_channels() const {
  return _impl_.channels_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::channels() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.channels)
  return _internal_channels();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_channels() {
  return &_impl_.channels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_channels() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.channels)
  return _internal_mutable_channels();
}

// repeated uint32 height = 4;
inline int DummyDataParameter::_internal_height_size() const {
  return _impl_.height_.size();
}
inline int DummyDataParameter::height_size() const {
  return _internal_height_size();
}
inline void DummyDataParameter::clear_height() {
  _impl_.height_.Clear();
}
inline uint32_t DummyDataParameter::_internal_height(int index) const {
  return _impl_.height_.Get(index);
}
inline uint32_t DummyDataParameter::height(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.height)
  return _internal_height(index);
}
inline void DummyDataParameter::set_height(int index, uint32_t value) {
  _impl_.height_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.height)
}
inline void DummyDataParameter::_internal_add_height(uint32_t value) {
  _impl_.height_.Add(value);
}
inline void DummyDataParameter::add_height(uint32_t value) {
  _internal_add_height(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.height)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_height() const {
  return _impl_.height_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::height() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.height)
  return _internal_height();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_height() {
  return &_impl_.height_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_height() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.height)
  return _internal_mutable_height();
}

// repeated uint32 width = 5;
inline int DummyDataParameter::_internal_width_size() const {
  return _impl_.width_.size();
}
inline int DummyDataParameter::width_size() const {
  return _internal_width_size();
}
inline void DummyDataParameter::clear_width() {
  _impl_.width_.Clear();
}
inline uint32_t DummyDataParameter::_internal_width(int index) const {
  return _impl_.width_.Get(index);
}
inline uint32_t DummyDataParameter::width(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.DummyDataParameter.width)
  return _internal_width(index);
}
inline void DummyDataParameter::set_width(int index, uint32_t value) {
  _impl_.width_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.DummyDataParameter.width)
}
inline void DummyDataParameter::_internal_add_width(uint32_t value) {
  _impl_.width_.Add(value);
}
inline void DummyDataParameter::add_width(uint32_t value) {
  _internal_add_width(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.DummyDataParameter.width)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::_internal_width() const {
  return _impl_.width_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DummyDataParameter::width() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.DummyDataParameter.width)
  return _internal_width();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::_internal_mutable_width() {
  return &_impl_.width_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DummyDataParameter::mutable_width() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.DummyDataParameter.width)
  return _internal_mutable_width();
}

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

// EltwiseParameter

// optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
inline bool EltwiseParameter::_internal_has_operation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool EltwiseParameter::has_operation() const {
  return _internal_has_operation();
}
inline void EltwiseParameter::clear_operation() {
  _impl_.operation_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::EltwiseParameter_EltwiseOp EltwiseParameter::_internal_operation() const {
  return static_cast< ::opencv_caffe::EltwiseParameter_EltwiseOp >(_impl_.operation_);
}
inline ::opencv_caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.operation)
  return _internal_operation();
}
inline void EltwiseParameter::_internal_set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value) {
  assert(::opencv_caffe::EltwiseParameter_EltwiseOp_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.operation_ = value;
}
inline void EltwiseParameter::set_operation(::opencv_caffe::EltwiseParameter_EltwiseOp value) {
  _internal_set_operation(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.operation)
}

// repeated float coeff = 2;
inline int EltwiseParameter::_internal_coeff_size() const {
  return _impl_.coeff_.size();
}
inline int EltwiseParameter::coeff_size() const {
  return _internal_coeff_size();
}
inline void EltwiseParameter::clear_coeff() {
  _impl_.coeff_.Clear();
}
inline float EltwiseParameter::_internal_coeff(int index) const {
  return _impl_.coeff_.Get(index);
}
inline float EltwiseParameter::coeff(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.coeff)
  return _internal_coeff(index);
}
inline void EltwiseParameter::set_coeff(int index, float value) {
  _impl_.coeff_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.coeff)
}
inline void EltwiseParameter::_internal_add_coeff(float value) {
  _impl_.coeff_.Add(value);
}
inline void EltwiseParameter::add_coeff(float value) {
  _internal_add_coeff(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.EltwiseParameter.coeff)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
EltwiseParameter::_internal_coeff() const {
  return _impl_.coeff_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
EltwiseParameter::coeff() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.EltwiseParameter.coeff)
  return _internal_coeff();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
EltwiseParameter::_internal_mutable_coeff() {
  return &_impl_.coeff_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
EltwiseParameter::mutable_coeff() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.EltwiseParameter.coeff)
  return _internal_mutable_coeff();
}

// optional bool stable_prod_grad = 3 [default = true];
inline bool EltwiseParameter::_internal_has_stable_prod_grad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool EltwiseParameter::has_stable_prod_grad() const {
  return _internal_has_stable_prod_grad();
}
inline void EltwiseParameter::clear_stable_prod_grad() {
  _impl_.stable_prod_grad_ = true;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool EltwiseParameter::_internal_stable_prod_grad() const {
  return _impl_.stable_prod_grad_;
}
inline bool EltwiseParameter::stable_prod_grad() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EltwiseParameter.stable_prod_grad)
  return _internal_stable_prod_grad();
}
inline void EltwiseParameter::_internal_set_stable_prod_grad(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.stable_prod_grad_ = value;
}
inline void EltwiseParameter::set_stable_prod_grad(bool value) {
  _internal_set_stable_prod_grad(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.EltwiseParameter.stable_prod_grad)
}

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

// ELUParameter

// optional float alpha = 1 [default = 1];
inline bool ELUParameter::_internal_has_alpha() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ELUParameter::has_alpha() const {
  return _internal_has_alpha();
}
inline void ELUParameter::clear_alpha() {
  _impl_.alpha_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float ELUParameter::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float ELUParameter::alpha() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ELUParameter.alpha)
  return _internal_alpha();
}
inline void ELUParameter::_internal_set_alpha(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.alpha_ = value;
}
inline void ELUParameter::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ELUParameter.alpha)
}

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

// EmbedParameter

// optional uint32 num_output = 1;
inline bool EmbedParameter::_internal_has_num_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool EmbedParameter::has_num_output() const {
  return _internal_has_num_output();
}
inline void EmbedParameter::clear_num_output() {
  _impl_.num_output_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t EmbedParameter::_internal_num_output() const {
  return _impl_.num_output_;
}
inline uint32_t EmbedParameter::num_output() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.num_output)
  return _internal_num_output();
}
inline void EmbedParameter::_internal_set_num_output(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_output_ = value;
}
inline void EmbedParameter::set_num_output(uint32_t value) {
  _internal_set_num_output(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.num_output)
}

// optional uint32 input_dim = 2;
inline bool EmbedParameter::_internal_has_input_dim() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool EmbedParameter::has_input_dim() const {
  return _internal_has_input_dim();
}
inline void EmbedParameter::clear_input_dim() {
  _impl_.input_dim_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t EmbedParameter::_internal_input_dim() const {
  return _impl_.input_dim_;
}
inline uint32_t EmbedParameter::input_dim() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.input_dim)
  return _internal_input_dim();
}
inline void EmbedParameter::_internal_set_input_dim(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.input_dim_ = value;
}
inline void EmbedParameter::set_input_dim(uint32_t value) {
  _internal_set_input_dim(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.input_dim)
}

// optional bool bias_term = 3 [default = true];
inline bool EmbedParameter::_internal_has_bias_term() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool EmbedParameter::has_bias_term() const {
  return _internal_has_bias_term();
}
inline void EmbedParameter::clear_bias_term() {
  _impl_.bias_term_ = true;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool EmbedParameter::_internal_bias_term() const {
  return _impl_.bias_term_;
}
inline bool EmbedParameter::bias_term() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.bias_term)
  return _internal_bias_term();
}
inline void EmbedParameter::_internal_set_bias_term(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.bias_term_ = value;
}
inline void EmbedParameter::set_bias_term(bool value) {
  _internal_set_bias_term(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.EmbedParameter.bias_term)
}

// optional .opencv_caffe.FillerParameter weight_filler = 4;
inline bool EmbedParameter::_internal_has_weight_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.weight_filler_ != nullptr);
  return value;
}
inline bool EmbedParameter::has_weight_filler() const {
  return _internal_has_weight_filler();
}
inline void EmbedParameter::clear_weight_filler() {
  if (_impl_.weight_filler_ != nullptr) _impl_.weight_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& EmbedParameter::_internal_weight_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.weight_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& EmbedParameter::weight_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.weight_filler)
  return _internal_weight_filler();
}
inline void EmbedParameter::unsafe_arena_set_allocated_weight_filler(
    ::opencv_caffe::FillerParameter* weight_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.weight_filler_);
  }
  _impl_.weight_filler_ = weight_filler;
  if (weight_filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.EmbedParameter.weight_filler)
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::release_weight_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = 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 ::opencv_caffe::FillerParameter* EmbedParameter::unsafe_arena_release_weight_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.EmbedParameter.weight_filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::_internal_mutable_weight_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.weight_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.weight_filler_ = p;
  }
  return _impl_.weight_filler_;
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::mutable_weight_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.EmbedParameter.weight_filler)
  return _msg;
}
inline void EmbedParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.weight_filler_;
  }
  if (weight_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(weight_filler);
    if (message_arena != submessage_arena) {
      weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, weight_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.weight_filler_ = weight_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.EmbedParameter.weight_filler)
}

// optional .opencv_caffe.FillerParameter bias_filler = 5;
inline bool EmbedParameter::_internal_has_bias_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_filler_ != nullptr);
  return value;
}
inline bool EmbedParameter::has_bias_filler() const {
  return _internal_has_bias_filler();
}
inline void EmbedParameter::clear_bias_filler() {
  if (_impl_.bias_filler_ != nullptr) _impl_.bias_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::FillerParameter& EmbedParameter::_internal_bias_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.bias_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& EmbedParameter::bias_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.EmbedParameter.bias_filler)
  return _internal_bias_filler();
}
inline void EmbedParameter::unsafe_arena_set_allocated_bias_filler(
    ::opencv_caffe::FillerParameter* bias_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_filler_);
  }
  _impl_.bias_filler_ = bias_filler;
  if (bias_filler) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.EmbedParameter.bias_filler)
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::release_bias_filler() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = 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 ::opencv_caffe::FillerParameter* EmbedParameter::unsafe_arena_release_bias_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.EmbedParameter.bias_filler)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::_internal_mutable_bias_filler() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.bias_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.bias_filler_ = p;
  }
  return _impl_.bias_filler_;
}
inline ::opencv_caffe::FillerParameter* EmbedParameter::mutable_bias_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.EmbedParameter.bias_filler)
  return _msg;
}
inline void EmbedParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_filler_;
  }
  if (bias_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_filler);
    if (message_arena != submessage_arena) {
      bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.bias_filler_ = bias_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.EmbedParameter.bias_filler)
}

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

// ExpParameter

// optional float base = 1 [default = -1];
inline bool ExpParameter::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ExpParameter::has_base() const {
  return _internal_has_base();
}
inline void ExpParameter::clear_base() {
  _impl_.base_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float ExpParameter::_internal_base() const {
  return _impl_.base_;
}
inline float ExpParameter::base() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.base)
  return _internal_base();
}
inline void ExpParameter::_internal_set_base(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.base_ = value;
}
inline void ExpParameter::set_base(float value) {
  _internal_set_base(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.base)
}

// optional float scale = 2 [default = 1];
inline bool ExpParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ExpParameter::has_scale() const {
  return _internal_has_scale();
}
inline void ExpParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float ExpParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float ExpParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.scale)
  return _internal_scale();
}
inline void ExpParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.scale_ = value;
}
inline void ExpParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.scale)
}

// optional float shift = 3 [default = 0];
inline bool ExpParameter::_internal_has_shift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ExpParameter::has_shift() const {
  return _internal_has_shift();
}
inline void ExpParameter::clear_shift() {
  _impl_.shift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float ExpParameter::_internal_shift() const {
  return _impl_.shift_;
}
inline float ExpParameter::shift() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ExpParameter.shift)
  return _internal_shift();
}
inline void ExpParameter::_internal_set_shift(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.shift_ = value;
}
inline void ExpParameter::set_shift(float value) {
  _internal_set_shift(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ExpParameter.shift)
}

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

// FlattenParameter

// optional int32 axis = 1 [default = 1];
inline bool FlattenParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool FlattenParameter::has_axis() const {
  return _internal_has_axis();
}
inline void FlattenParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t FlattenParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t FlattenParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FlattenParameter.axis)
  return _internal_axis();
}
inline void FlattenParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.axis_ = value;
}
inline void FlattenParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FlattenParameter.axis)
}

// optional int32 end_axis = 2 [default = -1];
inline bool FlattenParameter::_internal_has_end_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool FlattenParameter::has_end_axis() const {
  return _internal_has_end_axis();
}
inline void FlattenParameter::clear_end_axis() {
  _impl_.end_axis_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t FlattenParameter::_internal_end_axis() const {
  return _impl_.end_axis_;
}
inline int32_t FlattenParameter::end_axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.FlattenParameter.end_axis)
  return _internal_end_axis();
}
inline void FlattenParameter::_internal_set_end_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.end_axis_ = value;
}
inline void FlattenParameter::set_end_axis(int32_t value) {
  _internal_set_end_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.FlattenParameter.end_axis)
}

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

// HDF5DataParameter

// optional string source = 1;
inline bool HDF5DataParameter::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HDF5DataParameter::has_source() const {
  return _internal_has_source();
}
inline void HDF5DataParameter::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HDF5DataParameter::source() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HDF5DataParameter::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.source)
}
inline std::string* HDF5DataParameter::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.HDF5DataParameter.source)
  return _s;
}
inline const std::string& HDF5DataParameter::_internal_source() const {
  return _impl_.source_.Get();
}
inline void HDF5DataParameter::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* HDF5DataParameter::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* HDF5DataParameter::release_source() {
  // @@protoc_insertion_point(field_release:opencv_caffe.HDF5DataParameter.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HDF5DataParameter::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.HDF5DataParameter.source)
}

// optional uint32 batch_size = 2;
inline bool HDF5DataParameter::_internal_has_batch_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HDF5DataParameter::has_batch_size() const {
  return _internal_has_batch_size();
}
inline void HDF5DataParameter::clear_batch_size() {
  _impl_.batch_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t HDF5DataParameter::_internal_batch_size() const {
  return _impl_.batch_size_;
}
inline uint32_t HDF5DataParameter::batch_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.batch_size)
  return _internal_batch_size();
}
inline void HDF5DataParameter::_internal_set_batch_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.batch_size_ = value;
}
inline void HDF5DataParameter::set_batch_size(uint32_t value) {
  _internal_set_batch_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.batch_size)
}

// optional bool shuffle = 3 [default = false];
inline bool HDF5DataParameter::_internal_has_shuffle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HDF5DataParameter::has_shuffle() const {
  return _internal_has_shuffle();
}
inline void HDF5DataParameter::clear_shuffle() {
  _impl_.shuffle_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool HDF5DataParameter::_internal_shuffle() const {
  return _impl_.shuffle_;
}
inline bool HDF5DataParameter::shuffle() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.HDF5DataParameter.shuffle)
  return _internal_shuffle();
}
inline void HDF5DataParameter::_internal_set_shuffle(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.shuffle_ = value;
}
inline void HDF5DataParameter::set_shuffle(bool value) {
  _internal_set_shuffle(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.HDF5DataParameter.shuffle)
}

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

// HDF5OutputParameter

// optional string file_name = 1;
inline bool HDF5OutputParameter::_internal_has_file_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HDF5OutputParameter::has_file_name() const {
  return _internal_has_file_name();
}
inline void HDF5OutputParameter::clear_file_name() {
  _impl_.file_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HDF5OutputParameter::file_name() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.HDF5OutputParameter.file_name)
  return _internal_file_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HDF5OutputParameter::set_file_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.file_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.HDF5OutputParameter.file_name)
}
inline std::string* HDF5OutputParameter::mutable_file_name() {
  std::string* _s = _internal_mutable_file_name();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.HDF5OutputParameter.file_name)
  return _s;
}
inline const std::string& HDF5OutputParameter::_internal_file_name() const {
  return _impl_.file_name_.Get();
}
inline void HDF5OutputParameter::_internal_set_file_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.file_name_.Set(value, GetArenaForAllocation());
}
inline std::string* HDF5OutputParameter::_internal_mutable_file_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.file_name_.Mutable(GetArenaForAllocation());
}
inline std::string* HDF5OutputParameter::release_file_name() {
  // @@protoc_insertion_point(field_release:opencv_caffe.HDF5OutputParameter.file_name)
  if (!_internal_has_file_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.file_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.file_name_.IsDefault()) {
    _impl_.file_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HDF5OutputParameter::set_allocated_file_name(std::string* file_name) {
  if (file_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.file_name_.SetAllocated(file_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.file_name_.IsDefault()) {
    _impl_.file_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.HDF5OutputParameter.file_name)
}

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

// HingeLossParameter

// optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
inline bool HingeLossParameter::_internal_has_norm() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HingeLossParameter::has_norm() const {
  return _internal_has_norm();
}
inline void HingeLossParameter::clear_norm() {
  _impl_.norm_ = 1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::HingeLossParameter_Norm HingeLossParameter::_internal_norm() const {
  return static_cast< ::opencv_caffe::HingeLossParameter_Norm >(_impl_.norm_);
}
inline ::opencv_caffe::HingeLossParameter_Norm HingeLossParameter::norm() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.HingeLossParameter.norm)
  return _internal_norm();
}
inline void HingeLossParameter::_internal_set_norm(::opencv_caffe::HingeLossParameter_Norm value) {
  assert(::opencv_caffe::HingeLossParameter_Norm_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.norm_ = value;
}
inline void HingeLossParameter::set_norm(::opencv_caffe::HingeLossParameter_Norm value) {
  _internal_set_norm(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.HingeLossParameter.norm)
}

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

// ImageDataParameter

// optional string source = 1;
inline bool ImageDataParameter::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ImageDataParameter::has_source() const {
  return _internal_has_source();
}
inline void ImageDataParameter::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ImageDataParameter::source() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImageDataParameter::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.source)
}
inline std::string* ImageDataParameter::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.source)
  return _s;
}
inline const std::string& ImageDataParameter::_internal_source() const {
  return _impl_.source_.Get();
}
inline void ImageDataParameter::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* ImageDataParameter::release_source() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ImageDataParameter::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.source)
}

// optional uint32 batch_size = 4 [default = 1];
inline bool ImageDataParameter::_internal_has_batch_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool ImageDataParameter::has_batch_size() const {
  return _internal_has_batch_size();
}
inline void ImageDataParameter::clear_batch_size() {
  _impl_.batch_size_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t ImageDataParameter::_internal_batch_size() const {
  return _impl_.batch_size_;
}
inline uint32_t ImageDataParameter::batch_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.batch_size)
  return _internal_batch_size();
}
inline void ImageDataParameter::_internal_set_batch_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.batch_size_ = value;
}
inline void ImageDataParameter::set_batch_size(uint32_t value) {
  _internal_set_batch_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.batch_size)
}

// optional uint32 rand_skip = 7 [default = 0];
inline bool ImageDataParameter::_internal_has_rand_skip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ImageDataParameter::has_rand_skip() const {
  return _internal_has_rand_skip();
}
inline void ImageDataParameter::clear_rand_skip() {
  _impl_.rand_skip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ImageDataParameter::_internal_rand_skip() const {
  return _impl_.rand_skip_;
}
inline uint32_t ImageDataParameter::rand_skip() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.rand_skip)
  return _internal_rand_skip();
}
inline void ImageDataParameter::_internal_set_rand_skip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.rand_skip_ = value;
}
inline void ImageDataParameter::set_rand_skip(uint32_t value) {
  _internal_set_rand_skip(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.rand_skip)
}

// optional bool shuffle = 8 [default = false];
inline bool ImageDataParameter::_internal_has_shuffle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ImageDataParameter::has_shuffle() const {
  return _internal_has_shuffle();
}
inline void ImageDataParameter::clear_shuffle() {
  _impl_.shuffle_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool ImageDataParameter::_internal_shuffle() const {
  return _impl_.shuffle_;
}
inline bool ImageDataParameter::shuffle() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.shuffle)
  return _internal_shuffle();
}
inline void ImageDataParameter::_internal_set_shuffle(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.shuffle_ = value;
}
inline void ImageDataParameter::set_shuffle(bool value) {
  _internal_set_shuffle(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.shuffle)
}

// optional uint32 new_height = 9 [default = 0];
inline bool ImageDataParameter::_internal_has_new_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ImageDataParameter::has_new_height() const {
  return _internal_has_new_height();
}
inline void ImageDataParameter::clear_new_height() {
  _impl_.new_height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t ImageDataParameter::_internal_new_height() const {
  return _impl_.new_height_;
}
inline uint32_t ImageDataParameter::new_height() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.new_height)
  return _internal_new_height();
}
inline void ImageDataParameter::_internal_set_new_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.new_height_ = value;
}
inline void ImageDataParameter::set_new_height(uint32_t value) {
  _internal_set_new_height(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.new_height)
}

// optional uint32 new_width = 10 [default = 0];
inline bool ImageDataParameter::_internal_has_new_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ImageDataParameter::has_new_width() const {
  return _internal_has_new_width();
}
inline void ImageDataParameter::clear_new_width() {
  _impl_.new_width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t ImageDataParameter::_internal_new_width() const {
  return _impl_.new_width_;
}
inline uint32_t ImageDataParameter::new_width() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.new_width)
  return _internal_new_width();
}
inline void ImageDataParameter::_internal_set_new_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.new_width_ = value;
}
inline void ImageDataParameter::set_new_width(uint32_t value) {
  _internal_set_new_width(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.new_width)
}

// optional bool is_color = 11 [default = true];
inline bool ImageDataParameter::_internal_has_is_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ImageDataParameter::has_is_color() const {
  return _internal_has_is_color();
}
inline void ImageDataParameter::clear_is_color() {
  _impl_.is_color_ = true;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool ImageDataParameter::_internal_is_color() const {
  return _impl_.is_color_;
}
inline bool ImageDataParameter::is_color() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.is_color)
  return _internal_is_color();
}
inline void ImageDataParameter::_internal_set_is_color(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.is_color_ = value;
}
inline void ImageDataParameter::set_is_color(bool value) {
  _internal_set_is_color(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.is_color)
}

// optional float scale = 2 [default = 1];
inline bool ImageDataParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ImageDataParameter::has_scale() const {
  return _internal_has_scale();
}
inline void ImageDataParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float ImageDataParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float ImageDataParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.scale)
  return _internal_scale();
}
inline void ImageDataParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.scale_ = value;
}
inline void ImageDataParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.scale)
}

// optional string mean_file = 3;
inline bool ImageDataParameter::_internal_has_mean_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ImageDataParameter::has_mean_file() const {
  return _internal_has_mean_file();
}
inline void ImageDataParameter::clear_mean_file() {
  _impl_.mean_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ImageDataParameter::mean_file() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.mean_file)
  return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImageDataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mean_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.mean_file)
}
inline std::string* ImageDataParameter::mutable_mean_file() {
  std::string* _s = _internal_mutable_mean_file();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.mean_file)
  return _s;
}
inline const std::string& ImageDataParameter::_internal_mean_file() const {
  return _impl_.mean_file_.Get();
}
inline void ImageDataParameter::_internal_set_mean_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mean_file_.Set(value, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::_internal_mutable_mean_file() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mean_file_.Mutable(GetArenaForAllocation());
}
inline std::string* ImageDataParameter::release_mean_file() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.mean_file)
  if (!_internal_has_mean_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mean_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ImageDataParameter::set_allocated_mean_file(std::string* mean_file) {
  if (mean_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mean_file_.SetAllocated(mean_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.mean_file)
}

// optional uint32 crop_size = 5 [default = 0];
inline bool ImageDataParameter::_internal_has_crop_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ImageDataParameter::has_crop_size() const {
  return _internal_has_crop_size();
}
inline void ImageDataParameter::clear_crop_size() {
  _impl_.crop_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ImageDataParameter::_internal_crop_size() const {
  return _impl_.crop_size_;
}
inline uint32_t ImageDataParameter::crop_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.crop_size)
  return _internal_crop_size();
}
inline void ImageDataParameter::_internal_set_crop_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.crop_size_ = value;
}
inline void ImageDataParameter::set_crop_size(uint32_t value) {
  _internal_set_crop_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.crop_size)
}

// optional bool mirror = 6 [default = false];
inline bool ImageDataParameter::_internal_has_mirror() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ImageDataParameter::has_mirror() const {
  return _internal_has_mirror();
}
inline void ImageDataParameter::clear_mirror() {
  _impl_.mirror_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool ImageDataParameter::_internal_mirror() const {
  return _impl_.mirror_;
}
inline bool ImageDataParameter::mirror() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.mirror)
  return _internal_mirror();
}
inline void ImageDataParameter::_internal_set_mirror(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.mirror_ = value;
}
inline void ImageDataParameter::set_mirror(bool value) {
  _internal_set_mirror(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.mirror)
}

// optional string root_folder = 12 [default = ""];
inline bool ImageDataParameter::_internal_has_root_folder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ImageDataParameter::has_root_folder() const {
  return _internal_has_root_folder();
}
inline void ImageDataParameter::clear_root_folder() {
  _impl_.root_folder_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ImageDataParameter::root_folder() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ImageDataParameter.root_folder)
  return _internal_root_folder();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ImageDataParameter::set_root_folder(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.root_folder_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.ImageDataParameter.root_folder)
}
inline std::string* ImageDataParameter::mutable_root_folder() {
  std::string* _s = _internal_mutable_root_folder();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ImageDataParameter.root_folder)
  return _s;
}
inline const std::string& ImageDataParameter::_internal_root_folder() const {
  return _impl_.root_folder_.Get();
}
inline void ImageDataParameter::_internal_set_root_folder(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.root_folder_.Set(value, GetArenaForAllocation());
}
inline std::string* ImageDataParameter::_internal_mutable_root_folder() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.root_folder_.Mutable(GetArenaForAllocation());
}
inline std::string* ImageDataParameter::release_root_folder() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ImageDataParameter.root_folder)
  if (!_internal_has_root_folder()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.root_folder_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.root_folder_.IsDefault()) {
    _impl_.root_folder_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ImageDataParameter::set_allocated_root_folder(std::string* root_folder) {
  if (root_folder != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.root_folder_.SetAllocated(root_folder, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.root_folder_.IsDefault()) {
    _impl_.root_folder_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ImageDataParameter.root_folder)
}

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

// InfogainLossParameter

// optional string source = 1;
inline bool InfogainLossParameter::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool InfogainLossParameter::has_source() const {
  return _internal_has_source();
}
inline void InfogainLossParameter::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& InfogainLossParameter::source() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InfogainLossParameter.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InfogainLossParameter::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.InfogainLossParameter.source)
}
inline std::string* InfogainLossParameter::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.InfogainLossParameter.source)
  return _s;
}
inline const std::string& InfogainLossParameter::_internal_source() const {
  return _impl_.source_.Get();
}
inline void InfogainLossParameter::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* InfogainLossParameter::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* InfogainLossParameter::release_source() {
  // @@protoc_insertion_point(field_release:opencv_caffe.InfogainLossParameter.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void InfogainLossParameter::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.InfogainLossParameter.source)
}

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

// InnerProductParameter

// optional uint32 num_output = 1;
inline bool InnerProductParameter::_internal_has_num_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool InnerProductParameter::has_num_output() const {
  return _internal_has_num_output();
}
inline void InnerProductParameter::clear_num_output() {
  _impl_.num_output_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t InnerProductParameter::_internal_num_output() const {
  return _impl_.num_output_;
}
inline uint32_t InnerProductParameter::num_output() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.num_output)
  return _internal_num_output();
}
inline void InnerProductParameter::_internal_set_num_output(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_output_ = value;
}
inline void InnerProductParameter::set_num_output(uint32_t value) {
  _internal_set_num_output(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.num_output)
}

// optional bool bias_term = 2 [default = true];
inline bool InnerProductParameter::_internal_has_bias_term() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool InnerProductParameter::has_bias_term() const {
  return _internal_has_bias_term();
}
inline void InnerProductParameter::clear_bias_term() {
  _impl_.bias_term_ = true;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool InnerProductParameter::_internal_bias_term() const {
  return _impl_.bias_term_;
}
inline bool InnerProductParameter::bias_term() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.bias_term)
  return _internal_bias_term();
}
inline void InnerProductParameter::_internal_set_bias_term(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.bias_term_ = value;
}
inline void InnerProductParameter::set_bias_term(bool value) {
  _internal_set_bias_term(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.bias_term)
}

// optional .opencv_caffe.FillerParameter weight_filler = 3;
inline bool InnerProductParameter::_internal_has_weight_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.weight_filler_ != nullptr);
  return value;
}
inline bool InnerProductParameter::has_weight_filler() const {
  return _internal_has_weight_filler();
}
inline void InnerProductParameter::clear_weight_filler() {
  if (_impl_.weight_filler_ != nullptr) _impl_.weight_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& InnerProductParameter::_internal_weight_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.weight_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& InnerProductParameter::weight_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.weight_filler)
  return _internal_weight_filler();
}
inline void InnerProductParameter::unsafe_arena_set_allocated_weight_filler(
    ::opencv_caffe::FillerParameter* weight_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.weight_filler_);
  }
  _impl_.weight_filler_ = weight_filler;
  if (weight_filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.InnerProductParameter.weight_filler)
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::release_weight_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = 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 ::opencv_caffe::FillerParameter* InnerProductParameter::unsafe_arena_release_weight_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.InnerProductParameter.weight_filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::_internal_mutable_weight_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.weight_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.weight_filler_ = p;
  }
  return _impl_.weight_filler_;
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.InnerProductParameter.weight_filler)
  return _msg;
}
inline void InnerProductParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.weight_filler_;
  }
  if (weight_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(weight_filler);
    if (message_arena != submessage_arena) {
      weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, weight_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.weight_filler_ = weight_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.InnerProductParameter.weight_filler)
}

// optional .opencv_caffe.FillerParameter bias_filler = 4;
inline bool InnerProductParameter::_internal_has_bias_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_filler_ != nullptr);
  return value;
}
inline bool InnerProductParameter::has_bias_filler() const {
  return _internal_has_bias_filler();
}
inline void InnerProductParameter::clear_bias_filler() {
  if (_impl_.bias_filler_ != nullptr) _impl_.bias_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::FillerParameter& InnerProductParameter::_internal_bias_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.bias_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& InnerProductParameter::bias_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.bias_filler)
  return _internal_bias_filler();
}
inline void InnerProductParameter::unsafe_arena_set_allocated_bias_filler(
    ::opencv_caffe::FillerParameter* bias_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_filler_);
  }
  _impl_.bias_filler_ = bias_filler;
  if (bias_filler) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.InnerProductParameter.bias_filler)
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::release_bias_filler() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = 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 ::opencv_caffe::FillerParameter* InnerProductParameter::unsafe_arena_release_bias_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.InnerProductParameter.bias_filler)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::_internal_mutable_bias_filler() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.bias_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.bias_filler_ = p;
  }
  return _impl_.bias_filler_;
}
inline ::opencv_caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.InnerProductParameter.bias_filler)
  return _msg;
}
inline void InnerProductParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_filler_;
  }
  if (bias_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_filler);
    if (message_arena != submessage_arena) {
      bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.bias_filler_ = bias_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.InnerProductParameter.bias_filler)
}

// optional int32 axis = 5 [default = 1];
inline bool InnerProductParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool InnerProductParameter::has_axis() const {
  return _internal_has_axis();
}
inline void InnerProductParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t InnerProductParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t InnerProductParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.axis)
  return _internal_axis();
}
inline void InnerProductParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.axis_ = value;
}
inline void InnerProductParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.axis)
}

// optional bool transpose = 6 [default = false];
inline bool InnerProductParameter::_internal_has_transpose() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool InnerProductParameter::has_transpose() const {
  return _internal_has_transpose();
}
inline void InnerProductParameter::clear_transpose() {
  _impl_.transpose_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool InnerProductParameter::_internal_transpose() const {
  return _impl_.transpose_;
}
inline bool InnerProductParameter::transpose() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InnerProductParameter.transpose)
  return _internal_transpose();
}
inline void InnerProductParameter::_internal_set_transpose(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.transpose_ = value;
}
inline void InnerProductParameter::set_transpose(bool value) {
  _internal_set_transpose(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.InnerProductParameter.transpose)
}

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

// InputParameter

// repeated .opencv_caffe.BlobShape shape = 1;
inline int InputParameter::_internal_shape_size() const {
  return _impl_.shape_.size();
}
inline int InputParameter::shape_size() const {
  return _internal_shape_size();
}
inline void InputParameter::clear_shape() {
  _impl_.shape_.Clear();
}
inline ::opencv_caffe::BlobShape* InputParameter::mutable_shape(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.InputParameter.shape)
  return _impl_.shape_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >*
InputParameter::mutable_shape() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.InputParameter.shape)
  return &_impl_.shape_;
}
inline const ::opencv_caffe::BlobShape& InputParameter::_internal_shape(int index) const {
  return _impl_.shape_.Get(index);
}
inline const ::opencv_caffe::BlobShape& InputParameter::shape(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.InputParameter.shape)
  return _internal_shape(index);
}
inline ::opencv_caffe::BlobShape* InputParameter::_internal_add_shape() {
  return _impl_.shape_.Add();
}
inline ::opencv_caffe::BlobShape* InputParameter::add_shape() {
  ::opencv_caffe::BlobShape* _add = _internal_add_shape();
  // @@protoc_insertion_point(field_add:opencv_caffe.InputParameter.shape)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobShape >&
InputParameter::shape() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.InputParameter.shape)
  return _impl_.shape_;
}

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

// LogParameter

// optional float base = 1 [default = -1];
inline bool LogParameter::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LogParameter::has_base() const {
  return _internal_has_base();
}
inline void LogParameter::clear_base() {
  _impl_.base_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float LogParameter::_internal_base() const {
  return _impl_.base_;
}
inline float LogParameter::base() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.base)
  return _internal_base();
}
inline void LogParameter::_internal_set_base(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.base_ = value;
}
inline void LogParameter::set_base(float value) {
  _internal_set_base(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.base)
}

// optional float scale = 2 [default = 1];
inline bool LogParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LogParameter::has_scale() const {
  return _internal_has_scale();
}
inline void LogParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float LogParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float LogParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.scale)
  return _internal_scale();
}
inline void LogParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.scale_ = value;
}
inline void LogParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.scale)
}

// optional float shift = 3 [default = 0];
inline bool LogParameter::_internal_has_shift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LogParameter::has_shift() const {
  return _internal_has_shift();
}
inline void LogParameter::clear_shift() {
  _impl_.shift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float LogParameter::_internal_shift() const {
  return _impl_.shift_;
}
inline float LogParameter::shift() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LogParameter.shift)
  return _internal_shift();
}
inline void LogParameter::_internal_set_shift(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.shift_ = value;
}
inline void LogParameter::set_shift(float value) {
  _internal_set_shift(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LogParameter.shift)
}

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

// LRNParameter

// optional uint32 local_size = 1 [default = 5];
inline bool LRNParameter::_internal_has_local_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LRNParameter::has_local_size() const {
  return _internal_has_local_size();
}
inline void LRNParameter::clear_local_size() {
  _impl_.local_size_ = 5u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t LRNParameter::_internal_local_size() const {
  return _impl_.local_size_;
}
inline uint32_t LRNParameter::local_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.local_size)
  return _internal_local_size();
}
inline void LRNParameter::_internal_set_local_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.local_size_ = value;
}
inline void LRNParameter::set_local_size(uint32_t value) {
  _internal_set_local_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.local_size)
}

// optional float alpha = 2 [default = 1];
inline bool LRNParameter::_internal_has_alpha() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LRNParameter::has_alpha() const {
  return _internal_has_alpha();
}
inline void LRNParameter::clear_alpha() {
  _impl_.alpha_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float LRNParameter::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float LRNParameter::alpha() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.alpha)
  return _internal_alpha();
}
inline void LRNParameter::_internal_set_alpha(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.alpha_ = value;
}
inline void LRNParameter::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.alpha)
}

// optional float beta = 3 [default = 0.75];
inline bool LRNParameter::_internal_has_beta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LRNParameter::has_beta() const {
  return _internal_has_beta();
}
inline void LRNParameter::clear_beta() {
  _impl_.beta_ = 0.75f;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float LRNParameter::_internal_beta() const {
  return _impl_.beta_;
}
inline float LRNParameter::beta() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.beta)
  return _internal_beta();
}
inline void LRNParameter::_internal_set_beta(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.beta_ = value;
}
inline void LRNParameter::set_beta(float value) {
  _internal_set_beta(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.beta)
}

// optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
inline bool LRNParameter::_internal_has_norm_region() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LRNParameter::has_norm_region() const {
  return _internal_has_norm_region();
}
inline void LRNParameter::clear_norm_region() {
  _impl_.norm_region_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::LRNParameter_NormRegion LRNParameter::_internal_norm_region() const {
  return static_cast< ::opencv_caffe::LRNParameter_NormRegion >(_impl_.norm_region_);
}
inline ::opencv_caffe::LRNParameter_NormRegion LRNParameter::norm_region() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.norm_region)
  return _internal_norm_region();
}
inline void LRNParameter::_internal_set_norm_region(::opencv_caffe::LRNParameter_NormRegion value) {
  assert(::opencv_caffe::LRNParameter_NormRegion_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.norm_region_ = value;
}
inline void LRNParameter::set_norm_region(::opencv_caffe::LRNParameter_NormRegion value) {
  _internal_set_norm_region(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.norm_region)
}

// optional float k = 5 [default = 1];
inline bool LRNParameter::_internal_has_k() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool LRNParameter::has_k() const {
  return _internal_has_k();
}
inline void LRNParameter::clear_k() {
  _impl_.k_ = 1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float LRNParameter::_internal_k() const {
  return _impl_.k_;
}
inline float LRNParameter::k() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.k)
  return _internal_k();
}
inline void LRNParameter::_internal_set_k(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.k_ = value;
}
inline void LRNParameter::set_k(float value) {
  _internal_set_k(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.k)
}

// optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
inline bool LRNParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LRNParameter::has_engine() const {
  return _internal_has_engine();
}
inline void LRNParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::opencv_caffe::LRNParameter_Engine LRNParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::LRNParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::LRNParameter_Engine LRNParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.LRNParameter.engine)
  return _internal_engine();
}
inline void LRNParameter::_internal_set_engine(::opencv_caffe::LRNParameter_Engine value) {
  assert(::opencv_caffe::LRNParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.engine_ = value;
}
inline void LRNParameter::set_engine(::opencv_caffe::LRNParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.LRNParameter.engine)
}

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

// MemoryDataParameter

// optional uint32 batch_size = 1;
inline bool MemoryDataParameter::_internal_has_batch_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MemoryDataParameter::has_batch_size() const {
  return _internal_has_batch_size();
}
inline void MemoryDataParameter::clear_batch_size() {
  _impl_.batch_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t MemoryDataParameter::_internal_batch_size() const {
  return _impl_.batch_size_;
}
inline uint32_t MemoryDataParameter::batch_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.batch_size)
  return _internal_batch_size();
}
inline void MemoryDataParameter::_internal_set_batch_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.batch_size_ = value;
}
inline void MemoryDataParameter::set_batch_size(uint32_t value) {
  _internal_set_batch_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.batch_size)
}

// optional uint32 channels = 2;
inline bool MemoryDataParameter::_internal_has_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MemoryDataParameter::has_channels() const {
  return _internal_has_channels();
}
inline void MemoryDataParameter::clear_channels() {
  _impl_.channels_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t MemoryDataParameter::_internal_channels() const {
  return _impl_.channels_;
}
inline uint32_t MemoryDataParameter::channels() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.channels)
  return _internal_channels();
}
inline void MemoryDataParameter::_internal_set_channels(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.channels_ = value;
}
inline void MemoryDataParameter::set_channels(uint32_t value) {
  _internal_set_channels(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.channels)
}

// optional uint32 height = 3;
inline bool MemoryDataParameter::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MemoryDataParameter::has_height() const {
  return _internal_has_height();
}
inline void MemoryDataParameter::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t MemoryDataParameter::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t MemoryDataParameter::height() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.height)
  return _internal_height();
}
inline void MemoryDataParameter::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.height_ = value;
}
inline void MemoryDataParameter::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.height)
}

// optional uint32 width = 4;
inline bool MemoryDataParameter::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MemoryDataParameter::has_width() const {
  return _internal_has_width();
}
inline void MemoryDataParameter::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t MemoryDataParameter::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t MemoryDataParameter::width() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MemoryDataParameter.width)
  return _internal_width();
}
inline void MemoryDataParameter::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.width_ = value;
}
inline void MemoryDataParameter::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MemoryDataParameter.width)
}

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

// MVNParameter

// optional bool normalize_variance = 1 [default = true];
inline bool MVNParameter::_internal_has_normalize_variance() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MVNParameter::has_normalize_variance() const {
  return _internal_has_normalize_variance();
}
inline void MVNParameter::clear_normalize_variance() {
  _impl_.normalize_variance_ = true;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool MVNParameter::_internal_normalize_variance() const {
  return _impl_.normalize_variance_;
}
inline bool MVNParameter::normalize_variance() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.normalize_variance)
  return _internal_normalize_variance();
}
inline void MVNParameter::_internal_set_normalize_variance(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.normalize_variance_ = value;
}
inline void MVNParameter::set_normalize_variance(bool value) {
  _internal_set_normalize_variance(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.normalize_variance)
}

// optional bool across_channels = 2 [default = false];
inline bool MVNParameter::_internal_has_across_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MVNParameter::has_across_channels() const {
  return _internal_has_across_channels();
}
inline void MVNParameter::clear_across_channels() {
  _impl_.across_channels_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool MVNParameter::_internal_across_channels() const {
  return _impl_.across_channels_;
}
inline bool MVNParameter::across_channels() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.across_channels)
  return _internal_across_channels();
}
inline void MVNParameter::_internal_set_across_channels(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.across_channels_ = value;
}
inline void MVNParameter::set_across_channels(bool value) {
  _internal_set_across_channels(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.across_channels)
}

// optional float eps = 3 [default = 1e-09];
inline bool MVNParameter::_internal_has_eps() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MVNParameter::has_eps() const {
  return _internal_has_eps();
}
inline void MVNParameter::clear_eps() {
  _impl_.eps_ = 1e-09f;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float MVNParameter::_internal_eps() const {
  return _impl_.eps_;
}
inline float MVNParameter::eps() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.MVNParameter.eps)
  return _internal_eps();
}
inline void MVNParameter::_internal_set_eps(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.eps_ = value;
}
inline void MVNParameter::set_eps(float value) {
  _internal_set_eps(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.MVNParameter.eps)
}

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

// ParameterParameter

// optional .opencv_caffe.BlobShape shape = 1;
inline bool ParameterParameter::_internal_has_shape() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
  return value;
}
inline bool ParameterParameter::has_shape() const {
  return _internal_has_shape();
}
inline void ParameterParameter::clear_shape() {
  if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::BlobShape& ParameterParameter::_internal_shape() const {
  const ::opencv_caffe::BlobShape* p = _impl_.shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::BlobShape&>(
      ::opencv_caffe::_BlobShape_default_instance_);
}
inline const ::opencv_caffe::BlobShape& ParameterParameter::shape() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ParameterParameter.shape)
  return _internal_shape();
}
inline void ParameterParameter::unsafe_arena_set_allocated_shape(
    ::opencv_caffe::BlobShape* shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
  }
  _impl_.shape_ = shape;
  if (shape) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ParameterParameter.shape)
}
inline ::opencv_caffe::BlobShape* ParameterParameter::release_shape() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::BlobShape* temp = _impl_.shape_;
  _impl_.shape_ = 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 ::opencv_caffe::BlobShape* ParameterParameter::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ParameterParameter.shape)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::BlobShape* temp = _impl_.shape_;
  _impl_.shape_ = nullptr;
  return temp;
}
inline ::opencv_caffe::BlobShape* ParameterParameter::_internal_mutable_shape() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::BlobShape>(GetArenaForAllocation());
    _impl_.shape_ = p;
  }
  return _impl_.shape_;
}
inline ::opencv_caffe::BlobShape* ParameterParameter::mutable_shape() {
  ::opencv_caffe::BlobShape* _msg = _internal_mutable_shape();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ParameterParameter.shape)
  return _msg;
}
inline void ParameterParameter::set_allocated_shape(::opencv_caffe::BlobShape* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.shape_;
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shape);
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ParameterParameter.shape)
}

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

// PoolingParameter

// optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
inline bool PoolingParameter::_internal_has_pool() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PoolingParameter::has_pool() const {
  return _internal_has_pool();
}
inline void PoolingParameter::clear_pool() {
  _impl_.pool_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::PoolingParameter_PoolMethod PoolingParameter::_internal_pool() const {
  return static_cast< ::opencv_caffe::PoolingParameter_PoolMethod >(_impl_.pool_);
}
inline ::opencv_caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pool)
  return _internal_pool();
}
inline void PoolingParameter::_internal_set_pool(::opencv_caffe::PoolingParameter_PoolMethod value) {
  assert(::opencv_caffe::PoolingParameter_PoolMethod_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pool_ = value;
}
inline void PoolingParameter::set_pool(::opencv_caffe::PoolingParameter_PoolMethod value) {
  _internal_set_pool(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pool)
}

// optional uint32 pad = 4 [default = 0];
inline bool PoolingParameter::_internal_has_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PoolingParameter::has_pad() const {
  return _internal_has_pad();
}
inline void PoolingParameter::clear_pad() {
  _impl_.pad_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t PoolingParameter::_internal_pad() const {
  return _impl_.pad_;
}
inline uint32_t PoolingParameter::pad() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad)
  return _internal_pad();
}
inline void PoolingParameter::_internal_set_pad(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.pad_ = value;
}
inline void PoolingParameter::set_pad(uint32_t value) {
  _internal_set_pad(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad)
}

// optional uint32 pad_h = 9 [default = 0];
inline bool PoolingParameter::_internal_has_pad_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool PoolingParameter::has_pad_h() const {
  return _internal_has_pad_h();
}
inline void PoolingParameter::clear_pad_h() {
  _impl_.pad_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t PoolingParameter::_internal_pad_h() const {
  return _impl_.pad_h_;
}
inline uint32_t PoolingParameter::pad_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad_h)
  return _internal_pad_h();
}
inline void PoolingParameter::_internal_set_pad_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.pad_h_ = value;
}
inline void PoolingParameter::set_pad_h(uint32_t value) {
  _internal_set_pad_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad_h)
}

// optional uint32 pad_w = 10 [default = 0];
inline bool PoolingParameter::_internal_has_pad_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool PoolingParameter::has_pad_w() const {
  return _internal_has_pad_w();
}
inline void PoolingParameter::clear_pad_w() {
  _impl_.pad_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t PoolingParameter::_internal_pad_w() const {
  return _impl_.pad_w_;
}
inline uint32_t PoolingParameter::pad_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.pad_w)
  return _internal_pad_w();
}
inline void PoolingParameter::_internal_set_pad_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.pad_w_ = value;
}
inline void PoolingParameter::set_pad_w(uint32_t value) {
  _internal_set_pad_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.pad_w)
}

// optional uint32 kernel_size = 2;
inline bool PoolingParameter::_internal_has_kernel_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PoolingParameter::has_kernel_size() const {
  return _internal_has_kernel_size();
}
inline void PoolingParameter::clear_kernel_size() {
  _impl_.kernel_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t PoolingParameter::_internal_kernel_size() const {
  return _impl_.kernel_size_;
}
inline uint32_t PoolingParameter::kernel_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_size)
  return _internal_kernel_size();
}
inline void PoolingParameter::_internal_set_kernel_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.kernel_size_ = value;
}
inline void PoolingParameter::set_kernel_size(uint32_t value) {
  _internal_set_kernel_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_size)
}

// optional uint32 kernel_h = 5;
inline bool PoolingParameter::_internal_has_kernel_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PoolingParameter::has_kernel_h() const {
  return _internal_has_kernel_h();
}
inline void PoolingParameter::clear_kernel_h() {
  _impl_.kernel_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t PoolingParameter::_internal_kernel_h() const {
  return _impl_.kernel_h_;
}
inline uint32_t PoolingParameter::kernel_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_h)
  return _internal_kernel_h();
}
inline void PoolingParameter::_internal_set_kernel_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.kernel_h_ = value;
}
inline void PoolingParameter::set_kernel_h(uint32_t value) {
  _internal_set_kernel_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_h)
}

// optional uint32 kernel_w = 6;
inline bool PoolingParameter::_internal_has_kernel_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool PoolingParameter::has_kernel_w() const {
  return _internal_has_kernel_w();
}
inline void PoolingParameter::clear_kernel_w() {
  _impl_.kernel_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t PoolingParameter::_internal_kernel_w() const {
  return _impl_.kernel_w_;
}
inline uint32_t PoolingParameter::kernel_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.kernel_w)
  return _internal_kernel_w();
}
inline void PoolingParameter::_internal_set_kernel_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.kernel_w_ = value;
}
inline void PoolingParameter::set_kernel_w(uint32_t value) {
  _internal_set_kernel_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.kernel_w)
}

// optional uint32 stride = 3 [default = 1];
inline bool PoolingParameter::_internal_has_stride() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool PoolingParameter::has_stride() const {
  return _internal_has_stride();
}
inline void PoolingParameter::clear_stride() {
  _impl_.stride_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t PoolingParameter::_internal_stride() const {
  return _impl_.stride_;
}
inline uint32_t PoolingParameter::stride() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride)
  return _internal_stride();
}
inline void PoolingParameter::_internal_set_stride(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.stride_ = value;
}
inline void PoolingParameter::set_stride(uint32_t value) {
  _internal_set_stride(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride)
}

// optional uint32 stride_h = 7;
inline bool PoolingParameter::_internal_has_stride_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool PoolingParameter::has_stride_h() const {
  return _internal_has_stride_h();
}
inline void PoolingParameter::clear_stride_h() {
  _impl_.stride_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t PoolingParameter::_internal_stride_h() const {
  return _impl_.stride_h_;
}
inline uint32_t PoolingParameter::stride_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride_h)
  return _internal_stride_h();
}
inline void PoolingParameter::_internal_set_stride_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.stride_h_ = value;
}
inline void PoolingParameter::set_stride_h(uint32_t value) {
  _internal_set_stride_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride_h)
}

// optional uint32 stride_w = 8;
inline bool PoolingParameter::_internal_has_stride_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool PoolingParameter::has_stride_w() const {
  return _internal_has_stride_w();
}
inline void PoolingParameter::clear_stride_w() {
  _impl_.stride_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t PoolingParameter::_internal_stride_w() const {
  return _impl_.stride_w_;
}
inline uint32_t PoolingParameter::stride_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.stride_w)
  return _internal_stride_w();
}
inline void PoolingParameter::_internal_set_stride_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.stride_w_ = value;
}
inline void PoolingParameter::set_stride_w(uint32_t value) {
  _internal_set_stride_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.stride_w)
}

// optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
inline bool PoolingParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool PoolingParameter::has_engine() const {
  return _internal_has_engine();
}
inline void PoolingParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::opencv_caffe::PoolingParameter_Engine PoolingParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::PoolingParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::PoolingParameter_Engine PoolingParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.engine)
  return _internal_engine();
}
inline void PoolingParameter::_internal_set_engine(::opencv_caffe::PoolingParameter_Engine value) {
  assert(::opencv_caffe::PoolingParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.engine_ = value;
}
inline void PoolingParameter::set_engine(::opencv_caffe::PoolingParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.engine)
}

// optional bool global_pooling = 12 [default = false];
inline bool PoolingParameter::_internal_has_global_pooling() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool PoolingParameter::has_global_pooling() const {
  return _internal_has_global_pooling();
}
inline void PoolingParameter::clear_global_pooling() {
  _impl_.global_pooling_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool PoolingParameter::_internal_global_pooling() const {
  return _impl_.global_pooling_;
}
inline bool PoolingParameter::global_pooling() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.global_pooling)
  return _internal_global_pooling();
}
inline void PoolingParameter::_internal_set_global_pooling(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.global_pooling_ = value;
}
inline void PoolingParameter::set_global_pooling(bool value) {
  _internal_set_global_pooling(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.global_pooling)
}

// optional bool ceil_mode = 13 [default = true];
inline bool PoolingParameter::_internal_has_ceil_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool PoolingParameter::has_ceil_mode() const {
  return _internal_has_ceil_mode();
}
inline void PoolingParameter::clear_ceil_mode() {
  _impl_.ceil_mode_ = true;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline bool PoolingParameter::_internal_ceil_mode() const {
  return _impl_.ceil_mode_;
}
inline bool PoolingParameter::ceil_mode() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PoolingParameter.ceil_mode)
  return _internal_ceil_mode();
}
inline void PoolingParameter::_internal_set_ceil_mode(bool value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.ceil_mode_ = value;
}
inline void PoolingParameter::set_ceil_mode(bool value) {
  _internal_set_ceil_mode(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PoolingParameter.ceil_mode)
}

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

// PowerParameter

// optional float power = 1 [default = 1];
inline bool PowerParameter::_internal_has_power() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PowerParameter::has_power() const {
  return _internal_has_power();
}
inline void PowerParameter::clear_power() {
  _impl_.power_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float PowerParameter::_internal_power() const {
  return _impl_.power_;
}
inline float PowerParameter::power() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.power)
  return _internal_power();
}
inline void PowerParameter::_internal_set_power(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.power_ = value;
}
inline void PowerParameter::set_power(float value) {
  _internal_set_power(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.power)
}

// optional float scale = 2 [default = 1];
inline bool PowerParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PowerParameter::has_scale() const {
  return _internal_has_scale();
}
inline void PowerParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float PowerParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float PowerParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.scale)
  return _internal_scale();
}
inline void PowerParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.scale_ = value;
}
inline void PowerParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.scale)
}

// optional float shift = 3 [default = 0];
inline bool PowerParameter::_internal_has_shift() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PowerParameter::has_shift() const {
  return _internal_has_shift();
}
inline void PowerParameter::clear_shift() {
  _impl_.shift_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float PowerParameter::_internal_shift() const {
  return _impl_.shift_;
}
inline float PowerParameter::shift() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PowerParameter.shift)
  return _internal_shift();
}
inline void PowerParameter::_internal_set_shift(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.shift_ = value;
}
inline void PowerParameter::set_shift(float value) {
  _internal_set_shift(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PowerParameter.shift)
}

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

// PythonParameter

// optional string module = 1;
inline bool PythonParameter::_internal_has_module() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PythonParameter::has_module() const {
  return _internal_has_module();
}
inline void PythonParameter::clear_module() {
  _impl_.module_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PythonParameter::module() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.module)
  return _internal_module();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PythonParameter::set_module(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.module_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.module)
}
inline std::string* PythonParameter::mutable_module() {
  std::string* _s = _internal_mutable_module();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.module)
  return _s;
}
inline const std::string& PythonParameter::_internal_module() const {
  return _impl_.module_.Get();
}
inline void PythonParameter::_internal_set_module(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.module_.Set(value, GetArenaForAllocation());
}
inline std::string* PythonParameter::_internal_mutable_module() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.module_.Mutable(GetArenaForAllocation());
}
inline std::string* PythonParameter::release_module() {
  // @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.module)
  if (!_internal_has_module()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.module_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.module_.IsDefault()) {
    _impl_.module_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PythonParameter::set_allocated_module(std::string* module) {
  if (module != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.module_.SetAllocated(module, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.module_.IsDefault()) {
    _impl_.module_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.module)
}

// optional string layer = 2;
inline bool PythonParameter::_internal_has_layer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PythonParameter::has_layer() const {
  return _internal_has_layer();
}
inline void PythonParameter::clear_layer() {
  _impl_.layer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PythonParameter::layer() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.layer)
  return _internal_layer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PythonParameter::set_layer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.layer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.layer)
}
inline std::string* PythonParameter::mutable_layer() {
  std::string* _s = _internal_mutable_layer();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.layer)
  return _s;
}
inline const std::string& PythonParameter::_internal_layer() const {
  return _impl_.layer_.Get();
}
inline void PythonParameter::_internal_set_layer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.layer_.Set(value, GetArenaForAllocation());
}
inline std::string* PythonParameter::_internal_mutable_layer() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.layer_.Mutable(GetArenaForAllocation());
}
inline std::string* PythonParameter::release_layer() {
  // @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.layer)
  if (!_internal_has_layer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.layer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.layer_.IsDefault()) {
    _impl_.layer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PythonParameter::set_allocated_layer(std::string* layer) {
  if (layer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.layer_.SetAllocated(layer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.layer_.IsDefault()) {
    _impl_.layer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.layer)
}

// optional string param_str = 3 [default = ""];
inline bool PythonParameter::_internal_has_param_str() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PythonParameter::has_param_str() const {
  return _internal_has_param_str();
}
inline void PythonParameter::clear_param_str() {
  _impl_.param_str_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& PythonParameter::param_str() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.param_str)
  return _internal_param_str();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PythonParameter::set_param_str(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.param_str_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.param_str)
}
inline std::string* PythonParameter::mutable_param_str() {
  std::string* _s = _internal_mutable_param_str();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.PythonParameter.param_str)
  return _s;
}
inline const std::string& PythonParameter::_internal_param_str() const {
  return _impl_.param_str_.Get();
}
inline void PythonParameter::_internal_set_param_str(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.param_str_.Set(value, GetArenaForAllocation());
}
inline std::string* PythonParameter::_internal_mutable_param_str() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.param_str_.Mutable(GetArenaForAllocation());
}
inline std::string* PythonParameter::release_param_str() {
  // @@protoc_insertion_point(field_release:opencv_caffe.PythonParameter.param_str)
  if (!_internal_has_param_str()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.param_str_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param_str_.IsDefault()) {
    _impl_.param_str_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PythonParameter::set_allocated_param_str(std::string* param_str) {
  if (param_str != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.param_str_.SetAllocated(param_str, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.param_str_.IsDefault()) {
    _impl_.param_str_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PythonParameter.param_str)
}

// optional bool share_in_parallel = 4 [default = false];
inline bool PythonParameter::_internal_has_share_in_parallel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PythonParameter::has_share_in_parallel() const {
  return _internal_has_share_in_parallel();
}
inline void PythonParameter::clear_share_in_parallel() {
  _impl_.share_in_parallel_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool PythonParameter::_internal_share_in_parallel() const {
  return _impl_.share_in_parallel_;
}
inline bool PythonParameter::share_in_parallel() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PythonParameter.share_in_parallel)
  return _internal_share_in_parallel();
}
inline void PythonParameter::_internal_set_share_in_parallel(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.share_in_parallel_ = value;
}
inline void PythonParameter::set_share_in_parallel(bool value) {
  _internal_set_share_in_parallel(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PythonParameter.share_in_parallel)
}

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

// RecurrentParameter

// optional uint32 num_output = 1 [default = 0];
inline bool RecurrentParameter::_internal_has_num_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RecurrentParameter::has_num_output() const {
  return _internal_has_num_output();
}
inline void RecurrentParameter::clear_num_output() {
  _impl_.num_output_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t RecurrentParameter::_internal_num_output() const {
  return _impl_.num_output_;
}
inline uint32_t RecurrentParameter::num_output() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.num_output)
  return _internal_num_output();
}
inline void RecurrentParameter::_internal_set_num_output(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_output_ = value;
}
inline void RecurrentParameter::set_num_output(uint32_t value) {
  _internal_set_num_output(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.num_output)
}

// optional .opencv_caffe.FillerParameter weight_filler = 2;
inline bool RecurrentParameter::_internal_has_weight_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.weight_filler_ != nullptr);
  return value;
}
inline bool RecurrentParameter::has_weight_filler() const {
  return _internal_has_weight_filler();
}
inline void RecurrentParameter::clear_weight_filler() {
  if (_impl_.weight_filler_ != nullptr) _impl_.weight_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& RecurrentParameter::_internal_weight_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.weight_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& RecurrentParameter::weight_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.weight_filler)
  return _internal_weight_filler();
}
inline void RecurrentParameter::unsafe_arena_set_allocated_weight_filler(
    ::opencv_caffe::FillerParameter* weight_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.weight_filler_);
  }
  _impl_.weight_filler_ = weight_filler;
  if (weight_filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.RecurrentParameter.weight_filler)
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::release_weight_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = 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 ::opencv_caffe::FillerParameter* RecurrentParameter::unsafe_arena_release_weight_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.RecurrentParameter.weight_filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::_internal_mutable_weight_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.weight_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.weight_filler_ = p;
  }
  return _impl_.weight_filler_;
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::mutable_weight_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.RecurrentParameter.weight_filler)
  return _msg;
}
inline void RecurrentParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.weight_filler_;
  }
  if (weight_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(weight_filler);
    if (message_arena != submessage_arena) {
      weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, weight_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.weight_filler_ = weight_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.RecurrentParameter.weight_filler)
}

// optional .opencv_caffe.FillerParameter bias_filler = 3;
inline bool RecurrentParameter::_internal_has_bias_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_filler_ != nullptr);
  return value;
}
inline bool RecurrentParameter::has_bias_filler() const {
  return _internal_has_bias_filler();
}
inline void RecurrentParameter::clear_bias_filler() {
  if (_impl_.bias_filler_ != nullptr) _impl_.bias_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::FillerParameter& RecurrentParameter::_internal_bias_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.bias_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& RecurrentParameter::bias_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.bias_filler)
  return _internal_bias_filler();
}
inline void RecurrentParameter::unsafe_arena_set_allocated_bias_filler(
    ::opencv_caffe::FillerParameter* bias_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_filler_);
  }
  _impl_.bias_filler_ = bias_filler;
  if (bias_filler) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.RecurrentParameter.bias_filler)
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::release_bias_filler() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = 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 ::opencv_caffe::FillerParameter* RecurrentParameter::unsafe_arena_release_bias_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.RecurrentParameter.bias_filler)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::_internal_mutable_bias_filler() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.bias_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.bias_filler_ = p;
  }
  return _impl_.bias_filler_;
}
inline ::opencv_caffe::FillerParameter* RecurrentParameter::mutable_bias_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.RecurrentParameter.bias_filler)
  return _msg;
}
inline void RecurrentParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_filler_;
  }
  if (bias_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_filler);
    if (message_arena != submessage_arena) {
      bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.bias_filler_ = bias_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.RecurrentParameter.bias_filler)
}

// optional bool debug_info = 4 [default = false];
inline bool RecurrentParameter::_internal_has_debug_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RecurrentParameter::has_debug_info() const {
  return _internal_has_debug_info();
}
inline void RecurrentParameter::clear_debug_info() {
  _impl_.debug_info_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool RecurrentParameter::_internal_debug_info() const {
  return _impl_.debug_info_;
}
inline bool RecurrentParameter::debug_info() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.debug_info)
  return _internal_debug_info();
}
inline void RecurrentParameter::_internal_set_debug_info(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.debug_info_ = value;
}
inline void RecurrentParameter::set_debug_info(bool value) {
  _internal_set_debug_info(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.debug_info)
}

// optional bool expose_hidden = 5 [default = false];
inline bool RecurrentParameter::_internal_has_expose_hidden() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool RecurrentParameter::has_expose_hidden() const {
  return _internal_has_expose_hidden();
}
inline void RecurrentParameter::clear_expose_hidden() {
  _impl_.expose_hidden_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool RecurrentParameter::_internal_expose_hidden() const {
  return _impl_.expose_hidden_;
}
inline bool RecurrentParameter::expose_hidden() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.RecurrentParameter.expose_hidden)
  return _internal_expose_hidden();
}
inline void RecurrentParameter::_internal_set_expose_hidden(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.expose_hidden_ = value;
}
inline void RecurrentParameter::set_expose_hidden(bool value) {
  _internal_set_expose_hidden(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.RecurrentParameter.expose_hidden)
}

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

// ReductionParameter

// optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
inline bool ReductionParameter::_internal_has_operation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ReductionParameter::has_operation() const {
  return _internal_has_operation();
}
inline void ReductionParameter::clear_operation() {
  _impl_.operation_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::opencv_caffe::ReductionParameter_ReductionOp ReductionParameter::_internal_operation() const {
  return static_cast< ::opencv_caffe::ReductionParameter_ReductionOp >(_impl_.operation_);
}
inline ::opencv_caffe::ReductionParameter_ReductionOp ReductionParameter::operation() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.operation)
  return _internal_operation();
}
inline void ReductionParameter::_internal_set_operation(::opencv_caffe::ReductionParameter_ReductionOp value) {
  assert(::opencv_caffe::ReductionParameter_ReductionOp_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.operation_ = value;
}
inline void ReductionParameter::set_operation(::opencv_caffe::ReductionParameter_ReductionOp value) {
  _internal_set_operation(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.operation)
}

// optional int32 axis = 2 [default = 0];
inline bool ReductionParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ReductionParameter::has_axis() const {
  return _internal_has_axis();
}
inline void ReductionParameter::clear_axis() {
  _impl_.axis_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t ReductionParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t ReductionParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.axis)
  return _internal_axis();
}
inline void ReductionParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.axis_ = value;
}
inline void ReductionParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.axis)
}

// optional float coeff = 3 [default = 1];
inline bool ReductionParameter::_internal_has_coeff() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ReductionParameter::has_coeff() const {
  return _internal_has_coeff();
}
inline void ReductionParameter::clear_coeff() {
  _impl_.coeff_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float ReductionParameter::_internal_coeff() const {
  return _impl_.coeff_;
}
inline float ReductionParameter::coeff() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReductionParameter.coeff)
  return _internal_coeff();
}
inline void ReductionParameter::_internal_set_coeff(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.coeff_ = value;
}
inline void ReductionParameter::set_coeff(float value) {
  _internal_set_coeff(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReductionParameter.coeff)
}

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

// ReLUParameter

// optional float negative_slope = 1 [default = 0];
inline bool ReLUParameter::_internal_has_negative_slope() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ReLUParameter::has_negative_slope() const {
  return _internal_has_negative_slope();
}
inline void ReLUParameter::clear_negative_slope() {
  _impl_.negative_slope_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float ReLUParameter::_internal_negative_slope() const {
  return _impl_.negative_slope_;
}
inline float ReLUParameter::negative_slope() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReLUParameter.negative_slope)
  return _internal_negative_slope();
}
inline void ReLUParameter::_internal_set_negative_slope(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.negative_slope_ = value;
}
inline void ReLUParameter::set_negative_slope(float value) {
  _internal_set_negative_slope(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReLUParameter.negative_slope)
}

// optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
inline bool ReLUParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ReLUParameter::has_engine() const {
  return _internal_has_engine();
}
inline void ReLUParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::opencv_caffe::ReLUParameter_Engine ReLUParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::ReLUParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::ReLUParameter_Engine ReLUParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReLUParameter.engine)
  return _internal_engine();
}
inline void ReLUParameter::_internal_set_engine(::opencv_caffe::ReLUParameter_Engine value) {
  assert(::opencv_caffe::ReLUParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.engine_ = value;
}
inline void ReLUParameter::set_engine(::opencv_caffe::ReLUParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReLUParameter.engine)
}

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

// ReshapeParameter

// optional .opencv_caffe.BlobShape shape = 1;
inline bool ReshapeParameter::_internal_has_shape() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.shape_ != nullptr);
  return value;
}
inline bool ReshapeParameter::has_shape() const {
  return _internal_has_shape();
}
inline void ReshapeParameter::clear_shape() {
  if (_impl_.shape_ != nullptr) _impl_.shape_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::BlobShape& ReshapeParameter::_internal_shape() const {
  const ::opencv_caffe::BlobShape* p = _impl_.shape_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::BlobShape&>(
      ::opencv_caffe::_BlobShape_default_instance_);
}
inline const ::opencv_caffe::BlobShape& ReshapeParameter::shape() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.shape)
  return _internal_shape();
}
inline void ReshapeParameter::unsafe_arena_set_allocated_shape(
    ::opencv_caffe::BlobShape* shape) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
  }
  _impl_.shape_ = shape;
  if (shape) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ReshapeParameter.shape)
}
inline ::opencv_caffe::BlobShape* ReshapeParameter::release_shape() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::BlobShape* temp = _impl_.shape_;
  _impl_.shape_ = 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 ::opencv_caffe::BlobShape* ReshapeParameter::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ReshapeParameter.shape)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::BlobShape* temp = _impl_.shape_;
  _impl_.shape_ = nullptr;
  return temp;
}
inline ::opencv_caffe::BlobShape* ReshapeParameter::_internal_mutable_shape() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::BlobShape>(GetArenaForAllocation());
    _impl_.shape_ = p;
  }
  return _impl_.shape_;
}
inline ::opencv_caffe::BlobShape* ReshapeParameter::mutable_shape() {
  ::opencv_caffe::BlobShape* _msg = _internal_mutable_shape();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ReshapeParameter.shape)
  return _msg;
}
inline void ReshapeParameter::set_allocated_shape(::opencv_caffe::BlobShape* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.shape_;
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shape);
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ReshapeParameter.shape)
}

// optional int32 axis = 2 [default = 0];
inline bool ReshapeParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ReshapeParameter::has_axis() const {
  return _internal_has_axis();
}
inline void ReshapeParameter::clear_axis() {
  _impl_.axis_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ReshapeParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t ReshapeParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.axis)
  return _internal_axis();
}
inline void ReshapeParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void ReshapeParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReshapeParameter.axis)
}

// optional int32 num_axes = 3 [default = -1];
inline bool ReshapeParameter::_internal_has_num_axes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ReshapeParameter::has_num_axes() const {
  return _internal_has_num_axes();
}
inline void ReshapeParameter::clear_num_axes() {
  _impl_.num_axes_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t ReshapeParameter::_internal_num_axes() const {
  return _impl_.num_axes_;
}
inline int32_t ReshapeParameter::num_axes() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ReshapeParameter.num_axes)
  return _internal_num_axes();
}
inline void ReshapeParameter::_internal_set_num_axes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_axes_ = value;
}
inline void ReshapeParameter::set_num_axes(int32_t value) {
  _internal_set_num_axes(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ReshapeParameter.num_axes)
}

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

// ScaleParameter

// optional int32 axis = 1 [default = 1];
inline bool ScaleParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ScaleParameter::has_axis() const {
  return _internal_has_axis();
}
inline void ScaleParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t ScaleParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t ScaleParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.axis)
  return _internal_axis();
}
inline void ScaleParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.axis_ = value;
}
inline void ScaleParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.axis)
}

// optional int32 num_axes = 2 [default = 1];
inline bool ScaleParameter::_internal_has_num_axes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ScaleParameter::has_num_axes() const {
  return _internal_has_num_axes();
}
inline void ScaleParameter::clear_num_axes() {
  _impl_.num_axes_ = 1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t ScaleParameter::_internal_num_axes() const {
  return _impl_.num_axes_;
}
inline int32_t ScaleParameter::num_axes() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.num_axes)
  return _internal_num_axes();
}
inline void ScaleParameter::_internal_set_num_axes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.num_axes_ = value;
}
inline void ScaleParameter::set_num_axes(int32_t value) {
  _internal_set_num_axes(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.num_axes)
}

// optional .opencv_caffe.FillerParameter filler = 3;
inline bool ScaleParameter::_internal_has_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.filler_ != nullptr);
  return value;
}
inline bool ScaleParameter::has_filler() const {
  return _internal_has_filler();
}
inline void ScaleParameter::clear_filler() {
  if (_impl_.filler_ != nullptr) _impl_.filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& ScaleParameter::_internal_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& ScaleParameter::filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.filler)
  return _internal_filler();
}
inline void ScaleParameter::unsafe_arena_set_allocated_filler(
    ::opencv_caffe::FillerParameter* filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.filler_);
  }
  _impl_.filler_ = filler;
  if (filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ScaleParameter.filler)
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::release_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.filler_;
  _impl_.filler_ = 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 ::opencv_caffe::FillerParameter* ScaleParameter::unsafe_arena_release_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ScaleParameter.filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.filler_;
  _impl_.filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::_internal_mutable_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.filler_ = p;
  }
  return _impl_.filler_;
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::mutable_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ScaleParameter.filler)
  return _msg;
}
inline void ScaleParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.filler_;
  }
  if (filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(filler);
    if (message_arena != submessage_arena) {
      filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filler_ = filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ScaleParameter.filler)
}

// optional bool bias_term = 4 [default = false];
inline bool ScaleParameter::_internal_has_bias_term() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ScaleParameter::has_bias_term() const {
  return _internal_has_bias_term();
}
inline void ScaleParameter::clear_bias_term() {
  _impl_.bias_term_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool ScaleParameter::_internal_bias_term() const {
  return _impl_.bias_term_;
}
inline bool ScaleParameter::bias_term() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.bias_term)
  return _internal_bias_term();
}
inline void ScaleParameter::_internal_set_bias_term(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.bias_term_ = value;
}
inline void ScaleParameter::set_bias_term(bool value) {
  _internal_set_bias_term(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ScaleParameter.bias_term)
}

// optional .opencv_caffe.FillerParameter bias_filler = 5;
inline bool ScaleParameter::_internal_has_bias_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_filler_ != nullptr);
  return value;
}
inline bool ScaleParameter::has_bias_filler() const {
  return _internal_has_bias_filler();
}
inline void ScaleParameter::clear_bias_filler() {
  if (_impl_.bias_filler_ != nullptr) _impl_.bias_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::FillerParameter& ScaleParameter::_internal_bias_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.bias_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& ScaleParameter::bias_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ScaleParameter.bias_filler)
  return _internal_bias_filler();
}
inline void ScaleParameter::unsafe_arena_set_allocated_bias_filler(
    ::opencv_caffe::FillerParameter* bias_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_filler_);
  }
  _impl_.bias_filler_ = bias_filler;
  if (bias_filler) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.ScaleParameter.bias_filler)
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::release_bias_filler() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = 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 ::opencv_caffe::FillerParameter* ScaleParameter::unsafe_arena_release_bias_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.ScaleParameter.bias_filler)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::_internal_mutable_bias_filler() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.bias_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.bias_filler_ = p;
  }
  return _impl_.bias_filler_;
}
inline ::opencv_caffe::FillerParameter* ScaleParameter::mutable_bias_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.ScaleParameter.bias_filler)
  return _msg;
}
inline void ScaleParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_filler_;
  }
  if (bias_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_filler);
    if (message_arena != submessage_arena) {
      bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.bias_filler_ = bias_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.ScaleParameter.bias_filler)
}

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

// SigmoidParameter

// optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
inline bool SigmoidParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SigmoidParameter::has_engine() const {
  return _internal_has_engine();
}
inline void SigmoidParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::SigmoidParameter_Engine SigmoidParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::SigmoidParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::SigmoidParameter_Engine SigmoidParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SigmoidParameter.engine)
  return _internal_engine();
}
inline void SigmoidParameter::_internal_set_engine(::opencv_caffe::SigmoidParameter_Engine value) {
  assert(::opencv_caffe::SigmoidParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.engine_ = value;
}
inline void SigmoidParameter::set_engine(::opencv_caffe::SigmoidParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SigmoidParameter.engine)
}

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

// SliceParameter

// optional int32 axis = 3 [default = 1];
inline bool SliceParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SliceParameter::has_axis() const {
  return _internal_has_axis();
}
inline void SliceParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SliceParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t SliceParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.axis)
  return _internal_axis();
}
inline void SliceParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void SliceParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.axis)
}

// repeated uint32 slice_point = 2;
inline int SliceParameter::_internal_slice_point_size() const {
  return _impl_.slice_point_.size();
}
inline int SliceParameter::slice_point_size() const {
  return _internal_slice_point_size();
}
inline void SliceParameter::clear_slice_point() {
  _impl_.slice_point_.Clear();
}
inline uint32_t SliceParameter::_internal_slice_point(int index) const {
  return _impl_.slice_point_.Get(index);
}
inline uint32_t SliceParameter::slice_point(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.slice_point)
  return _internal_slice_point(index);
}
inline void SliceParameter::set_slice_point(int index, uint32_t value) {
  _impl_.slice_point_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.slice_point)
}
inline void SliceParameter::_internal_add_slice_point(uint32_t value) {
  _impl_.slice_point_.Add(value);
}
inline void SliceParameter::add_slice_point(uint32_t value) {
  _internal_add_slice_point(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.SliceParameter.slice_point)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SliceParameter::_internal_slice_point() const {
  return _impl_.slice_point_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SliceParameter::slice_point() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.SliceParameter.slice_point)
  return _internal_slice_point();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SliceParameter::_internal_mutable_slice_point() {
  return &_impl_.slice_point_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SliceParameter::mutable_slice_point() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.SliceParameter.slice_point)
  return _internal_mutable_slice_point();
}

// optional uint32 slice_dim = 1 [default = 1];
inline bool SliceParameter::_internal_has_slice_dim() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SliceParameter::has_slice_dim() const {
  return _internal_has_slice_dim();
}
inline void SliceParameter::clear_slice_dim() {
  _impl_.slice_dim_ = 1u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t SliceParameter::_internal_slice_dim() const {
  return _impl_.slice_dim_;
}
inline uint32_t SliceParameter::slice_dim() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SliceParameter.slice_dim)
  return _internal_slice_dim();
}
inline void SliceParameter::_internal_set_slice_dim(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.slice_dim_ = value;
}
inline void SliceParameter::set_slice_dim(uint32_t value) {
  _internal_set_slice_dim(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SliceParameter.slice_dim)
}

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

// SoftmaxParameter

// optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
inline bool SoftmaxParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SoftmaxParameter::has_engine() const {
  return _internal_has_engine();
}
inline void SoftmaxParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::SoftmaxParameter_Engine SoftmaxParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::SoftmaxParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SoftmaxParameter.engine)
  return _internal_engine();
}
inline void SoftmaxParameter::_internal_set_engine(::opencv_caffe::SoftmaxParameter_Engine value) {
  assert(::opencv_caffe::SoftmaxParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.engine_ = value;
}
inline void SoftmaxParameter::set_engine(::opencv_caffe::SoftmaxParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SoftmaxParameter.engine)
}

// optional int32 axis = 2 [default = 1];
inline bool SoftmaxParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SoftmaxParameter::has_axis() const {
  return _internal_has_axis();
}
inline void SoftmaxParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SoftmaxParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t SoftmaxParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SoftmaxParameter.axis)
  return _internal_axis();
}
inline void SoftmaxParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void SoftmaxParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SoftmaxParameter.axis)
}

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

// TanHParameter

// optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
inline bool TanHParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TanHParameter::has_engine() const {
  return _internal_has_engine();
}
inline void TanHParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::opencv_caffe::TanHParameter_Engine TanHParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::TanHParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::TanHParameter_Engine TanHParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TanHParameter.engine)
  return _internal_engine();
}
inline void TanHParameter::_internal_set_engine(::opencv_caffe::TanHParameter_Engine value) {
  assert(::opencv_caffe::TanHParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.engine_ = value;
}
inline void TanHParameter::set_engine(::opencv_caffe::TanHParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TanHParameter.engine)
}

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

// TileParameter

// optional int32 axis = 1 [default = 1];
inline bool TileParameter::_internal_has_axis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TileParameter::has_axis() const {
  return _internal_has_axis();
}
inline void TileParameter::clear_axis() {
  _impl_.axis_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t TileParameter::_internal_axis() const {
  return _impl_.axis_;
}
inline int32_t TileParameter::axis() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TileParameter.axis)
  return _internal_axis();
}
inline void TileParameter::_internal_set_axis(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axis_ = value;
}
inline void TileParameter::set_axis(int32_t value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TileParameter.axis)
}

// optional int32 tiles = 2;
inline bool TileParameter::_internal_has_tiles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TileParameter::has_tiles() const {
  return _internal_has_tiles();
}
inline void TileParameter::clear_tiles() {
  _impl_.tiles_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t TileParameter::_internal_tiles() const {
  return _impl_.tiles_;
}
inline int32_t TileParameter::tiles() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.TileParameter.tiles)
  return _internal_tiles();
}
inline void TileParameter::_internal_set_tiles(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.tiles_ = value;
}
inline void TileParameter::set_tiles(int32_t value) {
  _internal_set_tiles(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.TileParameter.tiles)
}

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

// ThresholdParameter

// optional float threshold = 1 [default = 0];
inline bool ThresholdParameter::_internal_has_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ThresholdParameter::has_threshold() const {
  return _internal_has_threshold();
}
inline void ThresholdParameter::clear_threshold() {
  _impl_.threshold_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float ThresholdParameter::_internal_threshold() const {
  return _impl_.threshold_;
}
inline float ThresholdParameter::threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ThresholdParameter.threshold)
  return _internal_threshold();
}
inline void ThresholdParameter::_internal_set_threshold(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.threshold_ = value;
}
inline void ThresholdParameter::set_threshold(float value) {
  _internal_set_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ThresholdParameter.threshold)
}

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

// WindowDataParameter

// optional string source = 1;
inline bool WindowDataParameter::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WindowDataParameter::has_source() const {
  return _internal_has_source();
}
inline void WindowDataParameter::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& WindowDataParameter::source() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.source)
}
inline std::string* WindowDataParameter::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.source)
  return _s;
}
inline const std::string& WindowDataParameter::_internal_source() const {
  return _impl_.source_.Get();
}
inline void WindowDataParameter::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_source() {
  // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WindowDataParameter::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.source)
}

// optional float scale = 2 [default = 1];
inline bool WindowDataParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool WindowDataParameter::has_scale() const {
  return _internal_has_scale();
}
inline void WindowDataParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float WindowDataParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float WindowDataParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.scale)
  return _internal_scale();
}
inline void WindowDataParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.scale_ = value;
}
inline void WindowDataParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.scale)
}

// optional string mean_file = 3;
inline bool WindowDataParameter::_internal_has_mean_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WindowDataParameter::has_mean_file() const {
  return _internal_has_mean_file();
}
inline void WindowDataParameter::clear_mean_file() {
  _impl_.mean_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& WindowDataParameter::mean_file() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.mean_file)
  return _internal_mean_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_mean_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mean_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.mean_file)
}
inline std::string* WindowDataParameter::mutable_mean_file() {
  std::string* _s = _internal_mutable_mean_file();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.mean_file)
  return _s;
}
inline const std::string& WindowDataParameter::_internal_mean_file() const {
  return _impl_.mean_file_.Get();
}
inline void WindowDataParameter::_internal_set_mean_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mean_file_.Set(value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_mean_file() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mean_file_.Mutable(GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_mean_file() {
  // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.mean_file)
  if (!_internal_has_mean_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mean_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WindowDataParameter::set_allocated_mean_file(std::string* mean_file) {
  if (mean_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mean_file_.SetAllocated(mean_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mean_file_.IsDefault()) {
    _impl_.mean_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.mean_file)
}

// optional uint32 batch_size = 4;
inline bool WindowDataParameter::_internal_has_batch_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool WindowDataParameter::has_batch_size() const {
  return _internal_has_batch_size();
}
inline void WindowDataParameter::clear_batch_size() {
  _impl_.batch_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t WindowDataParameter::_internal_batch_size() const {
  return _impl_.batch_size_;
}
inline uint32_t WindowDataParameter::batch_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.batch_size)
  return _internal_batch_size();
}
inline void WindowDataParameter::_internal_set_batch_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.batch_size_ = value;
}
inline void WindowDataParameter::set_batch_size(uint32_t value) {
  _internal_set_batch_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.batch_size)
}

// optional uint32 crop_size = 5 [default = 0];
inline bool WindowDataParameter::_internal_has_crop_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool WindowDataParameter::has_crop_size() const {
  return _internal_has_crop_size();
}
inline void WindowDataParameter::clear_crop_size() {
  _impl_.crop_size_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t WindowDataParameter::_internal_crop_size() const {
  return _impl_.crop_size_;
}
inline uint32_t WindowDataParameter::crop_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.crop_size)
  return _internal_crop_size();
}
inline void WindowDataParameter::_internal_set_crop_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.crop_size_ = value;
}
inline void WindowDataParameter::set_crop_size(uint32_t value) {
  _internal_set_crop_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.crop_size)
}

// optional bool mirror = 6 [default = false];
inline bool WindowDataParameter::_internal_has_mirror() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool WindowDataParameter::has_mirror() const {
  return _internal_has_mirror();
}
inline void WindowDataParameter::clear_mirror() {
  _impl_.mirror_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool WindowDataParameter::_internal_mirror() const {
  return _impl_.mirror_;
}
inline bool WindowDataParameter::mirror() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.mirror)
  return _internal_mirror();
}
inline void WindowDataParameter::_internal_set_mirror(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.mirror_ = value;
}
inline void WindowDataParameter::set_mirror(bool value) {
  _internal_set_mirror(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.mirror)
}

// optional float fg_threshold = 7 [default = 0.5];
inline bool WindowDataParameter::_internal_has_fg_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool WindowDataParameter::has_fg_threshold() const {
  return _internal_has_fg_threshold();
}
inline void WindowDataParameter::clear_fg_threshold() {
  _impl_.fg_threshold_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float WindowDataParameter::_internal_fg_threshold() const {
  return _impl_.fg_threshold_;
}
inline float WindowDataParameter::fg_threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.fg_threshold)
  return _internal_fg_threshold();
}
inline void WindowDataParameter::_internal_set_fg_threshold(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.fg_threshold_ = value;
}
inline void WindowDataParameter::set_fg_threshold(float value) {
  _internal_set_fg_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.fg_threshold)
}

// optional float bg_threshold = 8 [default = 0.5];
inline bool WindowDataParameter::_internal_has_bg_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool WindowDataParameter::has_bg_threshold() const {
  return _internal_has_bg_threshold();
}
inline void WindowDataParameter::clear_bg_threshold() {
  _impl_.bg_threshold_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline float WindowDataParameter::_internal_bg_threshold() const {
  return _impl_.bg_threshold_;
}
inline float WindowDataParameter::bg_threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.bg_threshold)
  return _internal_bg_threshold();
}
inline void WindowDataParameter::_internal_set_bg_threshold(float value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.bg_threshold_ = value;
}
inline void WindowDataParameter::set_bg_threshold(float value) {
  _internal_set_bg_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.bg_threshold)
}

// optional float fg_fraction = 9 [default = 0.25];
inline bool WindowDataParameter::_internal_has_fg_fraction() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool WindowDataParameter::has_fg_fraction() const {
  return _internal_has_fg_fraction();
}
inline void WindowDataParameter::clear_fg_fraction() {
  _impl_.fg_fraction_ = 0.25f;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline float WindowDataParameter::_internal_fg_fraction() const {
  return _impl_.fg_fraction_;
}
inline float WindowDataParameter::fg_fraction() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.fg_fraction)
  return _internal_fg_fraction();
}
inline void WindowDataParameter::_internal_set_fg_fraction(float value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.fg_fraction_ = value;
}
inline void WindowDataParameter::set_fg_fraction(float value) {
  _internal_set_fg_fraction(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.fg_fraction)
}

// optional uint32 context_pad = 10 [default = 0];
inline bool WindowDataParameter::_internal_has_context_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool WindowDataParameter::has_context_pad() const {
  return _internal_has_context_pad();
}
inline void WindowDataParameter::clear_context_pad() {
  _impl_.context_pad_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t WindowDataParameter::_internal_context_pad() const {
  return _impl_.context_pad_;
}
inline uint32_t WindowDataParameter::context_pad() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.context_pad)
  return _internal_context_pad();
}
inline void WindowDataParameter::_internal_set_context_pad(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.context_pad_ = value;
}
inline void WindowDataParameter::set_context_pad(uint32_t value) {
  _internal_set_context_pad(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.context_pad)
}

// optional string crop_mode = 11 [default = "warp"];
inline bool WindowDataParameter::_internal_has_crop_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool WindowDataParameter::has_crop_mode() const {
  return _internal_has_crop_mode();
}
inline void WindowDataParameter::clear_crop_mode() {
  _impl_.crop_mode_.ClearToDefault(::opencv_caffe::WindowDataParameter::Impl_::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& WindowDataParameter::crop_mode() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.crop_mode)
  if (_impl_.crop_mode_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_crop_mode_.get();
  return _internal_crop_mode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_crop_mode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.crop_mode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.crop_mode)
}
inline std::string* WindowDataParameter::mutable_crop_mode() {
  std::string* _s = _internal_mutable_crop_mode();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.crop_mode)
  return _s;
}
inline const std::string& WindowDataParameter::_internal_crop_mode() const {
  return _impl_.crop_mode_.Get();
}
inline void WindowDataParameter::_internal_set_crop_mode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.crop_mode_.Set(value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_crop_mode() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.crop_mode_.Mutable(::opencv_caffe::WindowDataParameter::Impl_::_i_give_permission_to_break_this_code_default_crop_mode_, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_crop_mode() {
  // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.crop_mode)
  if (!_internal_has_crop_mode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.crop_mode_.Release();
  return p;
}
inline void WindowDataParameter::set_allocated_crop_mode(std::string* crop_mode) {
  if (crop_mode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.crop_mode_.SetAllocated(crop_mode, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.crop_mode)
}

// optional bool cache_images = 12 [default = false];
inline bool WindowDataParameter::_internal_has_cache_images() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool WindowDataParameter::has_cache_images() const {
  return _internal_has_cache_images();
}
inline void WindowDataParameter::clear_cache_images() {
  _impl_.cache_images_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool WindowDataParameter::_internal_cache_images() const {
  return _impl_.cache_images_;
}
inline bool WindowDataParameter::cache_images() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.cache_images)
  return _internal_cache_images();
}
inline void WindowDataParameter::_internal_set_cache_images(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.cache_images_ = value;
}
inline void WindowDataParameter::set_cache_images(bool value) {
  _internal_set_cache_images(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.cache_images)
}

// optional string root_folder = 13 [default = ""];
inline bool WindowDataParameter::_internal_has_root_folder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool WindowDataParameter::has_root_folder() const {
  return _internal_has_root_folder();
}
inline void WindowDataParameter::clear_root_folder() {
  _impl_.root_folder_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& WindowDataParameter::root_folder() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.WindowDataParameter.root_folder)
  return _internal_root_folder();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WindowDataParameter::set_root_folder(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.root_folder_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.WindowDataParameter.root_folder)
}
inline std::string* WindowDataParameter::mutable_root_folder() {
  std::string* _s = _internal_mutable_root_folder();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.WindowDataParameter.root_folder)
  return _s;
}
inline const std::string& WindowDataParameter::_internal_root_folder() const {
  return _impl_.root_folder_.Get();
}
inline void WindowDataParameter::_internal_set_root_folder(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.root_folder_.Set(value, GetArenaForAllocation());
}
inline std::string* WindowDataParameter::_internal_mutable_root_folder() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.root_folder_.Mutable(GetArenaForAllocation());
}
inline std::string* WindowDataParameter::release_root_folder() {
  // @@protoc_insertion_point(field_release:opencv_caffe.WindowDataParameter.root_folder)
  if (!_internal_has_root_folder()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.root_folder_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.root_folder_.IsDefault()) {
    _impl_.root_folder_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WindowDataParameter::set_allocated_root_folder(std::string* root_folder) {
  if (root_folder != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.root_folder_.SetAllocated(root_folder, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.root_folder_.IsDefault()) {
    _impl_.root_folder_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.WindowDataParameter.root_folder)
}

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

// SPPParameter

// optional uint32 pyramid_height = 1;
inline bool SPPParameter::_internal_has_pyramid_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SPPParameter::has_pyramid_height() const {
  return _internal_has_pyramid_height();
}
inline void SPPParameter::clear_pyramid_height() {
  _impl_.pyramid_height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t SPPParameter::_internal_pyramid_height() const {
  return _impl_.pyramid_height_;
}
inline uint32_t SPPParameter::pyramid_height() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.pyramid_height)
  return _internal_pyramid_height();
}
inline void SPPParameter::_internal_set_pyramid_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pyramid_height_ = value;
}
inline void SPPParameter::set_pyramid_height(uint32_t value) {
  _internal_set_pyramid_height(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.pyramid_height)
}

// optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
inline bool SPPParameter::_internal_has_pool() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SPPParameter::has_pool() const {
  return _internal_has_pool();
}
inline void SPPParameter::clear_pool() {
  _impl_.pool_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::opencv_caffe::SPPParameter_PoolMethod SPPParameter::_internal_pool() const {
  return static_cast< ::opencv_caffe::SPPParameter_PoolMethod >(_impl_.pool_);
}
inline ::opencv_caffe::SPPParameter_PoolMethod SPPParameter::pool() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.pool)
  return _internal_pool();
}
inline void SPPParameter::_internal_set_pool(::opencv_caffe::SPPParameter_PoolMethod value) {
  assert(::opencv_caffe::SPPParameter_PoolMethod_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pool_ = value;
}
inline void SPPParameter::set_pool(::opencv_caffe::SPPParameter_PoolMethod value) {
  _internal_set_pool(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.pool)
}

// optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
inline bool SPPParameter::_internal_has_engine() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SPPParameter::has_engine() const {
  return _internal_has_engine();
}
inline void SPPParameter::clear_engine() {
  _impl_.engine_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::opencv_caffe::SPPParameter_Engine SPPParameter::_internal_engine() const {
  return static_cast< ::opencv_caffe::SPPParameter_Engine >(_impl_.engine_);
}
inline ::opencv_caffe::SPPParameter_Engine SPPParameter::engine() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.SPPParameter.engine)
  return _internal_engine();
}
inline void SPPParameter::_internal_set_engine(::opencv_caffe::SPPParameter_Engine value) {
  assert(::opencv_caffe::SPPParameter_Engine_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.engine_ = value;
}
inline void SPPParameter::set_engine(::opencv_caffe::SPPParameter_Engine value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.SPPParameter.engine)
}

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

// V1LayerParameter

// repeated string bottom = 2;
inline int V1LayerParameter::_internal_bottom_size() const {
  return _impl_.bottom_.size();
}
inline int V1LayerParameter::bottom_size() const {
  return _internal_bottom_size();
}
inline void V1LayerParameter::clear_bottom() {
  _impl_.bottom_.Clear();
}
inline std::string* V1LayerParameter::add_bottom() {
  std::string* _s = _internal_add_bottom();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.bottom)
  return _s;
}
inline const std::string& V1LayerParameter::_internal_bottom(int index) const {
  return _impl_.bottom_.Get(index);
}
inline const std::string& V1LayerParameter::bottom(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.bottom)
  return _internal_bottom(index);
}
inline std::string* V1LayerParameter::mutable_bottom(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.bottom)
  return _impl_.bottom_.Mutable(index);
}
inline void V1LayerParameter::set_bottom(int index, const std::string& value) {
  _impl_.bottom_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, std::string&& value) {
  _impl_.bottom_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.bottom_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::set_bottom(int index, const char* value, size_t size) {
  _impl_.bottom_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.bottom)
}
inline std::string* V1LayerParameter::_internal_add_bottom() {
  return _impl_.bottom_.Add();
}
inline void V1LayerParameter::add_bottom(const std::string& value) {
  _impl_.bottom_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(std::string&& value) {
  _impl_.bottom_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.bottom_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.V1LayerParameter.bottom)
}
inline void V1LayerParameter::add_bottom(const char* value, size_t size) {
  _impl_.bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.bottom)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
V1LayerParameter::bottom() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.bottom)
  return _impl_.bottom_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
V1LayerParameter::mutable_bottom() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.bottom)
  return &_impl_.bottom_;
}

// repeated string top = 3;
inline int V1LayerParameter::_internal_top_size() const {
  return _impl_.top_.size();
}
inline int V1LayerParameter::top_size() const {
  return _internal_top_size();
}
inline void V1LayerParameter::clear_top() {
  _impl_.top_.Clear();
}
inline std::string* V1LayerParameter::add_top() {
  std::string* _s = _internal_add_top();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.top)
  return _s;
}
inline const std::string& V1LayerParameter::_internal_top(int index) const {
  return _impl_.top_.Get(index);
}
inline const std::string& V1LayerParameter::top(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.top)
  return _internal_top(index);
}
inline std::string* V1LayerParameter::mutable_top(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.top)
  return _impl_.top_.Mutable(index);
}
inline void V1LayerParameter::set_top(int index, const std::string& value) {
  _impl_.top_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, std::string&& value) {
  _impl_.top_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.top_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::set_top(int index, const char* value, size_t size) {
  _impl_.top_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.top)
}
inline std::string* V1LayerParameter::_internal_add_top() {
  return _impl_.top_.Add();
}
inline void V1LayerParameter::add_top(const std::string& value) {
  _impl_.top_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(std::string&& value) {
  _impl_.top_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.top_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.V1LayerParameter.top)
}
inline void V1LayerParameter::add_top(const char* value, size_t size) {
  _impl_.top_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.top)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
V1LayerParameter::top() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.top)
  return _impl_.top_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
V1LayerParameter::mutable_top() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.top)
  return &_impl_.top_;
}

// optional string name = 4;
inline bool V1LayerParameter::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool V1LayerParameter::has_name() const {
  return _internal_has_name();
}
inline void V1LayerParameter::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& V1LayerParameter::name() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V1LayerParameter::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.name)
}
inline std::string* V1LayerParameter::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.name)
  return _s;
}
inline const std::string& V1LayerParameter::_internal_name() const {
  return _impl_.name_.Get();
}
inline void V1LayerParameter::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* V1LayerParameter::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* V1LayerParameter::release_name() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void V1LayerParameter::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.name)
}

// repeated .opencv_caffe.NetStateRule include = 32;
inline int V1LayerParameter::_internal_include_size() const {
  return _impl_.include_.size();
}
inline int V1LayerParameter::include_size() const {
  return _internal_include_size();
}
inline void V1LayerParameter::clear_include() {
  _impl_.include_.Clear();
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::mutable_include(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.include)
  return _impl_.include_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
V1LayerParameter::mutable_include() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.include)
  return &_impl_.include_;
}
inline const ::opencv_caffe::NetStateRule& V1LayerParameter::_internal_include(int index) const {
  return _impl_.include_.Get(index);
}
inline const ::opencv_caffe::NetStateRule& V1LayerParameter::include(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.include)
  return _internal_include(index);
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::_internal_add_include() {
  return _impl_.include_.Add();
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::add_include() {
  ::opencv_caffe::NetStateRule* _add = _internal_add_include();
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.include)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
V1LayerParameter::include() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.include)
  return _impl_.include_;
}

// repeated .opencv_caffe.NetStateRule exclude = 33;
inline int V1LayerParameter::_internal_exclude_size() const {
  return _impl_.exclude_.size();
}
inline int V1LayerParameter::exclude_size() const {
  return _internal_exclude_size();
}
inline void V1LayerParameter::clear_exclude() {
  _impl_.exclude_.Clear();
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::mutable_exclude(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.exclude)
  return _impl_.exclude_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >*
V1LayerParameter::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.exclude)
  return &_impl_.exclude_;
}
inline const ::opencv_caffe::NetStateRule& V1LayerParameter::_internal_exclude(int index) const {
  return _impl_.exclude_.Get(index);
}
inline const ::opencv_caffe::NetStateRule& V1LayerParameter::exclude(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.exclude)
  return _internal_exclude(index);
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::_internal_add_exclude() {
  return _impl_.exclude_.Add();
}
inline ::opencv_caffe::NetStateRule* V1LayerParameter::add_exclude() {
  ::opencv_caffe::NetStateRule* _add = _internal_add_exclude();
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.exclude)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::NetStateRule >&
V1LayerParameter::exclude() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.exclude)
  return _impl_.exclude_;
}

// optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
inline bool V1LayerParameter::_internal_has_type() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool V1LayerParameter::has_type() const {
  return _internal_has_type();
}
inline void V1LayerParameter::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline ::opencv_caffe::V1LayerParameter_LayerType V1LayerParameter::_internal_type() const {
  return static_cast< ::opencv_caffe::V1LayerParameter_LayerType >(_impl_.type_);
}
inline ::opencv_caffe::V1LayerParameter_LayerType V1LayerParameter::type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.type)
  return _internal_type();
}
inline void V1LayerParameter::_internal_set_type(::opencv_caffe::V1LayerParameter_LayerType value) {
  assert(::opencv_caffe::V1LayerParameter_LayerType_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.type_ = value;
}
inline void V1LayerParameter::set_type(::opencv_caffe::V1LayerParameter_LayerType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.type)
}

// repeated .opencv_caffe.BlobProto blobs = 6;
inline int V1LayerParameter::_internal_blobs_size() const {
  return _impl_.blobs_.size();
}
inline int V1LayerParameter::blobs_size() const {
  return _internal_blobs_size();
}
inline void V1LayerParameter::clear_blobs() {
  _impl_.blobs_.Clear();
}
inline ::opencv_caffe::BlobProto* V1LayerParameter::mutable_blobs(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.blobs)
  return _impl_.blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
V1LayerParameter::mutable_blobs() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blobs)
  return &_impl_.blobs_;
}
inline const ::opencv_caffe::BlobProto& V1LayerParameter::_internal_blobs(int index) const {
  return _impl_.blobs_.Get(index);
}
inline const ::opencv_caffe::BlobProto& V1LayerParameter::blobs(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blobs)
  return _internal_blobs(index);
}
inline ::opencv_caffe::BlobProto* V1LayerParameter::_internal_add_blobs() {
  return _impl_.blobs_.Add();
}
inline ::opencv_caffe::BlobProto* V1LayerParameter::add_blobs() {
  ::opencv_caffe::BlobProto* _add = _internal_add_blobs();
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blobs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
V1LayerParameter::blobs() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blobs)
  return _impl_.blobs_;
}

// repeated string param = 1001;
inline int V1LayerParameter::_internal_param_size() const {
  return _impl_.param_.size();
}
inline int V1LayerParameter::param_size() const {
  return _internal_param_size();
}
inline void V1LayerParameter::clear_param() {
  _impl_.param_.Clear();
}
inline std::string* V1LayerParameter::add_param() {
  std::string* _s = _internal_add_param();
  // @@protoc_insertion_point(field_add_mutable:opencv_caffe.V1LayerParameter.param)
  return _s;
}
inline const std::string& V1LayerParameter::_internal_param(int index) const {
  return _impl_.param_.Get(index);
}
inline const std::string& V1LayerParameter::param(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.param)
  return _internal_param(index);
}
inline std::string* V1LayerParameter::mutable_param(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.param)
  return _impl_.param_.Mutable(index);
}
inline void V1LayerParameter::set_param(int index, const std::string& value) {
  _impl_.param_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, std::string&& value) {
  _impl_.param_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.param_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::set_param(int index, const char* value, size_t size) {
  _impl_.param_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:opencv_caffe.V1LayerParameter.param)
}
inline std::string* V1LayerParameter::_internal_add_param() {
  return _impl_.param_.Add();
}
inline void V1LayerParameter::add_param(const std::string& value) {
  _impl_.param_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(std::string&& value) {
  _impl_.param_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.param_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:opencv_caffe.V1LayerParameter.param)
}
inline void V1LayerParameter::add_param(const char* value, size_t size) {
  _impl_.param_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:opencv_caffe.V1LayerParameter.param)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
V1LayerParameter::param() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.param)
  return _impl_.param_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
V1LayerParameter::mutable_param() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.param)
  return &_impl_.param_;
}

// repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
inline int V1LayerParameter::_internal_blob_share_mode_size() const {
  return _impl_.blob_share_mode_.size();
}
inline int V1LayerParameter::blob_share_mode_size() const {
  return _internal_blob_share_mode_size();
}
inline void V1LayerParameter::clear_blob_share_mode() {
  _impl_.blob_share_mode_.Clear();
}
inline ::opencv_caffe::V1LayerParameter_DimCheckMode V1LayerParameter::_internal_blob_share_mode(int index) const {
  return static_cast< ::opencv_caffe::V1LayerParameter_DimCheckMode >(_impl_.blob_share_mode_.Get(index));
}
inline ::opencv_caffe::V1LayerParameter_DimCheckMode V1LayerParameter::blob_share_mode(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blob_share_mode)
  return _internal_blob_share_mode(index);
}
inline void V1LayerParameter::set_blob_share_mode(int index, ::opencv_caffe::V1LayerParameter_DimCheckMode value) {
  assert(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(value));
  _impl_.blob_share_mode_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.blob_share_mode)
}
inline void V1LayerParameter::_internal_add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value) {
  assert(::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(value));
  _impl_.blob_share_mode_.Add(value);
}
inline void V1LayerParameter::add_blob_share_mode(::opencv_caffe::V1LayerParameter_DimCheckMode value) {
  _internal_add_blob_share_mode(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blob_share_mode)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
V1LayerParameter::blob_share_mode() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blob_share_mode)
  return _impl_.blob_share_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
V1LayerParameter::_internal_mutable_blob_share_mode() {
  return &_impl_.blob_share_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
V1LayerParameter::mutable_blob_share_mode() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blob_share_mode)
  return _internal_mutable_blob_share_mode();
}

// repeated float blobs_lr = 7;
inline int V1LayerParameter::_internal_blobs_lr_size() const {
  return _impl_.blobs_lr_.size();
}
inline int V1LayerParameter::blobs_lr_size() const {
  return _internal_blobs_lr_size();
}
inline void V1LayerParameter::clear_blobs_lr() {
  _impl_.blobs_lr_.Clear();
}
inline float V1LayerParameter::_internal_blobs_lr(int index) const {
  return _impl_.blobs_lr_.Get(index);
}
inline float V1LayerParameter::blobs_lr(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.blobs_lr)
  return _internal_blobs_lr(index);
}
inline void V1LayerParameter::set_blobs_lr(int index, float value) {
  _impl_.blobs_lr_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.blobs_lr)
}
inline void V1LayerParameter::_internal_add_blobs_lr(float value) {
  _impl_.blobs_lr_.Add(value);
}
inline void V1LayerParameter::add_blobs_lr(float value) {
  _internal_add_blobs_lr(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.blobs_lr)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::_internal_blobs_lr() const {
  return _impl_.blobs_lr_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::blobs_lr() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.blobs_lr)
  return _internal_blobs_lr();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::_internal_mutable_blobs_lr() {
  return &_impl_.blobs_lr_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::mutable_blobs_lr() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.blobs_lr)
  return _internal_mutable_blobs_lr();
}

// repeated float weight_decay = 8;
inline int V1LayerParameter::_internal_weight_decay_size() const {
  return _impl_.weight_decay_.size();
}
inline int V1LayerParameter::weight_decay_size() const {
  return _internal_weight_decay_size();
}
inline void V1LayerParameter::clear_weight_decay() {
  _impl_.weight_decay_.Clear();
}
inline float V1LayerParameter::_internal_weight_decay(int index) const {
  return _impl_.weight_decay_.Get(index);
}
inline float V1LayerParameter::weight_decay(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.weight_decay)
  return _internal_weight_decay(index);
}
inline void V1LayerParameter::set_weight_decay(int index, float value) {
  _impl_.weight_decay_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.weight_decay)
}
inline void V1LayerParameter::_internal_add_weight_decay(float value) {
  _impl_.weight_decay_.Add(value);
}
inline void V1LayerParameter::add_weight_decay(float value) {
  _internal_add_weight_decay(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.weight_decay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::_internal_weight_decay() const {
  return _impl_.weight_decay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::weight_decay() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.weight_decay)
  return _internal_weight_decay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::_internal_mutable_weight_decay() {
  return &_impl_.weight_decay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::mutable_weight_decay() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.weight_decay)
  return _internal_mutable_weight_decay();
}

// repeated float loss_weight = 35;
inline int V1LayerParameter::_internal_loss_weight_size() const {
  return _impl_.loss_weight_.size();
}
inline int V1LayerParameter::loss_weight_size() const {
  return _internal_loss_weight_size();
}
inline void V1LayerParameter::clear_loss_weight() {
  _impl_.loss_weight_.Clear();
}
inline float V1LayerParameter::_internal_loss_weight(int index) const {
  return _impl_.loss_weight_.Get(index);
}
inline float V1LayerParameter::loss_weight(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.loss_weight)
  return _internal_loss_weight(index);
}
inline void V1LayerParameter::set_loss_weight(int index, float value) {
  _impl_.loss_weight_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V1LayerParameter.loss_weight)
}
inline void V1LayerParameter::_internal_add_loss_weight(float value) {
  _impl_.loss_weight_.Add(value);
}
inline void V1LayerParameter::add_loss_weight(float value) {
  _internal_add_loss_weight(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V1LayerParameter.loss_weight)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::_internal_loss_weight() const {
  return _impl_.loss_weight_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V1LayerParameter::loss_weight() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V1LayerParameter.loss_weight)
  return _internal_loss_weight();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::_internal_mutable_loss_weight() {
  return &_impl_.loss_weight_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V1LayerParameter::mutable_loss_weight() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V1LayerParameter.loss_weight)
  return _internal_mutable_loss_weight();
}

// optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
inline bool V1LayerParameter::_internal_has_accuracy_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.accuracy_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_accuracy_param() const {
  return _internal_has_accuracy_param();
}
inline void V1LayerParameter::clear_accuracy_param() {
  if (_impl_.accuracy_param_ != nullptr) _impl_.accuracy_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline const ::opencv_caffe::AccuracyParameter& V1LayerParameter::_internal_accuracy_param() const {
  const ::opencv_caffe::AccuracyParameter* p = _impl_.accuracy_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::AccuracyParameter&>(
      ::opencv_caffe::_AccuracyParameter_default_instance_);
}
inline const ::opencv_caffe::AccuracyParameter& V1LayerParameter::accuracy_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.accuracy_param)
  return _internal_accuracy_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_accuracy_param(
    ::opencv_caffe::AccuracyParameter* accuracy_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.accuracy_param_);
  }
  _impl_.accuracy_param_ = accuracy_param;
  if (accuracy_param) {
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.accuracy_param)
}
inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::release_accuracy_param() {
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::opencv_caffe::AccuracyParameter* temp = _impl_.accuracy_param_;
  _impl_.accuracy_param_ = 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 ::opencv_caffe::AccuracyParameter* V1LayerParameter::unsafe_arena_release_accuracy_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.accuracy_param)
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::opencv_caffe::AccuracyParameter* temp = _impl_.accuracy_param_;
  _impl_.accuracy_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::_internal_mutable_accuracy_param() {
  _impl_._has_bits_[0] |= 0x00100000u;
  if (_impl_.accuracy_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::AccuracyParameter>(GetArenaForAllocation());
    _impl_.accuracy_param_ = p;
  }
  return _impl_.accuracy_param_;
}
inline ::opencv_caffe::AccuracyParameter* V1LayerParameter::mutable_accuracy_param() {
  ::opencv_caffe::AccuracyParameter* _msg = _internal_mutable_accuracy_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.accuracy_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_accuracy_param(::opencv_caffe::AccuracyParameter* accuracy_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.accuracy_param_;
  }
  if (accuracy_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(accuracy_param);
    if (message_arena != submessage_arena) {
      accuracy_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, accuracy_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  _impl_.accuracy_param_ = accuracy_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.accuracy_param)
}

// optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
inline bool V1LayerParameter::_internal_has_argmax_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.argmax_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_argmax_param() const {
  return _internal_has_argmax_param();
}
inline void V1LayerParameter::clear_argmax_param() {
  if (_impl_.argmax_param_ != nullptr) _impl_.argmax_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::opencv_caffe::ArgMaxParameter& V1LayerParameter::_internal_argmax_param() const {
  const ::opencv_caffe::ArgMaxParameter* p = _impl_.argmax_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ArgMaxParameter&>(
      ::opencv_caffe::_ArgMaxParameter_default_instance_);
}
inline const ::opencv_caffe::ArgMaxParameter& V1LayerParameter::argmax_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.argmax_param)
  return _internal_argmax_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_argmax_param(
    ::opencv_caffe::ArgMaxParameter* argmax_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.argmax_param_);
  }
  _impl_.argmax_param_ = argmax_param;
  if (argmax_param) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.argmax_param)
}
inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::release_argmax_param() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::opencv_caffe::ArgMaxParameter* temp = _impl_.argmax_param_;
  _impl_.argmax_param_ = 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 ::opencv_caffe::ArgMaxParameter* V1LayerParameter::unsafe_arena_release_argmax_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.argmax_param)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::opencv_caffe::ArgMaxParameter* temp = _impl_.argmax_param_;
  _impl_.argmax_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::_internal_mutable_argmax_param() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.argmax_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ArgMaxParameter>(GetArenaForAllocation());
    _impl_.argmax_param_ = p;
  }
  return _impl_.argmax_param_;
}
inline ::opencv_caffe::ArgMaxParameter* V1LayerParameter::mutable_argmax_param() {
  ::opencv_caffe::ArgMaxParameter* _msg = _internal_mutable_argmax_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.argmax_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_argmax_param(::opencv_caffe::ArgMaxParameter* argmax_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.argmax_param_;
  }
  if (argmax_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(argmax_param);
    if (message_arena != submessage_arena) {
      argmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, argmax_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.argmax_param_ = argmax_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.argmax_param)
}

// optional .opencv_caffe.ConcatParameter concat_param = 9;
inline bool V1LayerParameter::_internal_has_concat_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.concat_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_concat_param() const {
  return _internal_has_concat_param();
}
inline void V1LayerParameter::clear_concat_param() {
  if (_impl_.concat_param_ != nullptr) _impl_.concat_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::opencv_caffe::ConcatParameter& V1LayerParameter::_internal_concat_param() const {
  const ::opencv_caffe::ConcatParameter* p = _impl_.concat_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ConcatParameter&>(
      ::opencv_caffe::_ConcatParameter_default_instance_);
}
inline const ::opencv_caffe::ConcatParameter& V1LayerParameter::concat_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.concat_param)
  return _internal_concat_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_concat_param(
    ::opencv_caffe::ConcatParameter* concat_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.concat_param_);
  }
  _impl_.concat_param_ = concat_param;
  if (concat_param) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.concat_param)
}
inline ::opencv_caffe::ConcatParameter* V1LayerParameter::release_concat_param() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::opencv_caffe::ConcatParameter* temp = _impl_.concat_param_;
  _impl_.concat_param_ = 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 ::opencv_caffe::ConcatParameter* V1LayerParameter::unsafe_arena_release_concat_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.concat_param)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::opencv_caffe::ConcatParameter* temp = _impl_.concat_param_;
  _impl_.concat_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ConcatParameter* V1LayerParameter::_internal_mutable_concat_param() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.concat_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ConcatParameter>(GetArenaForAllocation());
    _impl_.concat_param_ = p;
  }
  return _impl_.concat_param_;
}
inline ::opencv_caffe::ConcatParameter* V1LayerParameter::mutable_concat_param() {
  ::opencv_caffe::ConcatParameter* _msg = _internal_mutable_concat_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.concat_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_concat_param(::opencv_caffe::ConcatParameter* concat_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.concat_param_;
  }
  if (concat_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(concat_param);
    if (message_arena != submessage_arena) {
      concat_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, concat_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.concat_param_ = concat_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.concat_param)
}

// optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
inline bool V1LayerParameter::_internal_has_contrastive_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contrastive_loss_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_contrastive_loss_param() const {
  return _internal_has_contrastive_loss_param();
}
inline void V1LayerParameter::clear_contrastive_loss_param() {
  if (_impl_.contrastive_loss_param_ != nullptr) _impl_.contrastive_loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline const ::opencv_caffe::ContrastiveLossParameter& V1LayerParameter::_internal_contrastive_loss_param() const {
  const ::opencv_caffe::ContrastiveLossParameter* p = _impl_.contrastive_loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ContrastiveLossParameter&>(
      ::opencv_caffe::_ContrastiveLossParameter_default_instance_);
}
inline const ::opencv_caffe::ContrastiveLossParameter& V1LayerParameter::contrastive_loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.contrastive_loss_param)
  return _internal_contrastive_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_contrastive_loss_param(
    ::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contrastive_loss_param_);
  }
  _impl_.contrastive_loss_param_ = contrastive_loss_param;
  if (contrastive_loss_param) {
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.contrastive_loss_param)
}
inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::release_contrastive_loss_param() {
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::opencv_caffe::ContrastiveLossParameter* temp = _impl_.contrastive_loss_param_;
  _impl_.contrastive_loss_param_ = 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 ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::unsafe_arena_release_contrastive_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.contrastive_loss_param)
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::opencv_caffe::ContrastiveLossParameter* temp = _impl_.contrastive_loss_param_;
  _impl_.contrastive_loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::_internal_mutable_contrastive_loss_param() {
  _impl_._has_bits_[0] |= 0x20000000u;
  if (_impl_.contrastive_loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ContrastiveLossParameter>(GetArenaForAllocation());
    _impl_.contrastive_loss_param_ = p;
  }
  return _impl_.contrastive_loss_param_;
}
inline ::opencv_caffe::ContrastiveLossParameter* V1LayerParameter::mutable_contrastive_loss_param() {
  ::opencv_caffe::ContrastiveLossParameter* _msg = _internal_mutable_contrastive_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.contrastive_loss_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_contrastive_loss_param(::opencv_caffe::ContrastiveLossParameter* contrastive_loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contrastive_loss_param_;
  }
  if (contrastive_loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contrastive_loss_param);
    if (message_arena != submessage_arena) {
      contrastive_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contrastive_loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  _impl_.contrastive_loss_param_ = contrastive_loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.contrastive_loss_param)
}

// optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
inline bool V1LayerParameter::_internal_has_convolution_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.convolution_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_convolution_param() const {
  return _internal_has_convolution_param();
}
inline void V1LayerParameter::clear_convolution_param() {
  if (_impl_.convolution_param_ != nullptr) _impl_.convolution_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::opencv_caffe::ConvolutionParameter& V1LayerParameter::_internal_convolution_param() const {
  const ::opencv_caffe::ConvolutionParameter* p = _impl_.convolution_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ConvolutionParameter&>(
      ::opencv_caffe::_ConvolutionParameter_default_instance_);
}
inline const ::opencv_caffe::ConvolutionParameter& V1LayerParameter::convolution_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.convolution_param)
  return _internal_convolution_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_convolution_param(
    ::opencv_caffe::ConvolutionParameter* convolution_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.convolution_param_);
  }
  _impl_.convolution_param_ = convolution_param;
  if (convolution_param) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.convolution_param)
}
inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::release_convolution_param() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::opencv_caffe::ConvolutionParameter* temp = _impl_.convolution_param_;
  _impl_.convolution_param_ = 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 ::opencv_caffe::ConvolutionParameter* V1LayerParameter::unsafe_arena_release_convolution_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.convolution_param)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::opencv_caffe::ConvolutionParameter* temp = _impl_.convolution_param_;
  _impl_.convolution_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::_internal_mutable_convolution_param() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.convolution_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ConvolutionParameter>(GetArenaForAllocation());
    _impl_.convolution_param_ = p;
  }
  return _impl_.convolution_param_;
}
inline ::opencv_caffe::ConvolutionParameter* V1LayerParameter::mutable_convolution_param() {
  ::opencv_caffe::ConvolutionParameter* _msg = _internal_mutable_convolution_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.convolution_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_convolution_param(::opencv_caffe::ConvolutionParameter* convolution_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.convolution_param_;
  }
  if (convolution_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(convolution_param);
    if (message_arena != submessage_arena) {
      convolution_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, convolution_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.convolution_param_ = convolution_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.convolution_param)
}

// optional .opencv_caffe.DataParameter data_param = 11;
inline bool V1LayerParameter::_internal_has_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_data_param() const {
  return _internal_has_data_param();
}
inline void V1LayerParameter::clear_data_param() {
  if (_impl_.data_param_ != nullptr) _impl_.data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::opencv_caffe::DataParameter& V1LayerParameter::_internal_data_param() const {
  const ::opencv_caffe::DataParameter* p = _impl_.data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DataParameter&>(
      ::opencv_caffe::_DataParameter_default_instance_);
}
inline const ::opencv_caffe::DataParameter& V1LayerParameter::data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.data_param)
  return _internal_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_data_param(
    ::opencv_caffe::DataParameter* data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.data_param_);
  }
  _impl_.data_param_ = data_param;
  if (data_param) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.data_param)
}
inline ::opencv_caffe::DataParameter* V1LayerParameter::release_data_param() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::opencv_caffe::DataParameter* temp = _impl_.data_param_;
  _impl_.data_param_ = 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 ::opencv_caffe::DataParameter* V1LayerParameter::unsafe_arena_release_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.data_param)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::opencv_caffe::DataParameter* temp = _impl_.data_param_;
  _impl_.data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DataParameter* V1LayerParameter::_internal_mutable_data_param() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DataParameter>(GetArenaForAllocation());
    _impl_.data_param_ = p;
  }
  return _impl_.data_param_;
}
inline ::opencv_caffe::DataParameter* V1LayerParameter::mutable_data_param() {
  ::opencv_caffe::DataParameter* _msg = _internal_mutable_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.data_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_data_param(::opencv_caffe::DataParameter* data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.data_param_;
  }
  if (data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data_param);
    if (message_arena != submessage_arena) {
      data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.data_param_ = data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.data_param)
}

// optional .opencv_caffe.DropoutParameter dropout_param = 12;
inline bool V1LayerParameter::_internal_has_dropout_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dropout_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_dropout_param() const {
  return _internal_has_dropout_param();
}
inline void V1LayerParameter::clear_dropout_param() {
  if (_impl_.dropout_param_ != nullptr) _impl_.dropout_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::opencv_caffe::DropoutParameter& V1LayerParameter::_internal_dropout_param() const {
  const ::opencv_caffe::DropoutParameter* p = _impl_.dropout_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DropoutParameter&>(
      ::opencv_caffe::_DropoutParameter_default_instance_);
}
inline const ::opencv_caffe::DropoutParameter& V1LayerParameter::dropout_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.dropout_param)
  return _internal_dropout_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_dropout_param(
    ::opencv_caffe::DropoutParameter* dropout_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dropout_param_);
  }
  _impl_.dropout_param_ = dropout_param;
  if (dropout_param) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.dropout_param)
}
inline ::opencv_caffe::DropoutParameter* V1LayerParameter::release_dropout_param() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::opencv_caffe::DropoutParameter* temp = _impl_.dropout_param_;
  _impl_.dropout_param_ = 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 ::opencv_caffe::DropoutParameter* V1LayerParameter::unsafe_arena_release_dropout_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.dropout_param)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::opencv_caffe::DropoutParameter* temp = _impl_.dropout_param_;
  _impl_.dropout_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DropoutParameter* V1LayerParameter::_internal_mutable_dropout_param() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.dropout_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DropoutParameter>(GetArenaForAllocation());
    _impl_.dropout_param_ = p;
  }
  return _impl_.dropout_param_;
}
inline ::opencv_caffe::DropoutParameter* V1LayerParameter::mutable_dropout_param() {
  ::opencv_caffe::DropoutParameter* _msg = _internal_mutable_dropout_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.dropout_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_dropout_param(::opencv_caffe::DropoutParameter* dropout_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dropout_param_;
  }
  if (dropout_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dropout_param);
    if (message_arena != submessage_arena) {
      dropout_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dropout_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.dropout_param_ = dropout_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.dropout_param)
}

// optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
inline bool V1LayerParameter::_internal_has_dummy_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dummy_data_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_dummy_data_param() const {
  return _internal_has_dummy_data_param();
}
inline void V1LayerParameter::clear_dummy_data_param() {
  if (_impl_.dummy_data_param_ != nullptr) _impl_.dummy_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline const ::opencv_caffe::DummyDataParameter& V1LayerParameter::_internal_dummy_data_param() const {
  const ::opencv_caffe::DummyDataParameter* p = _impl_.dummy_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::DummyDataParameter&>(
      ::opencv_caffe::_DummyDataParameter_default_instance_);
}
inline const ::opencv_caffe::DummyDataParameter& V1LayerParameter::dummy_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.dummy_data_param)
  return _internal_dummy_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_dummy_data_param(
    ::opencv_caffe::DummyDataParameter* dummy_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dummy_data_param_);
  }
  _impl_.dummy_data_param_ = dummy_data_param;
  if (dummy_data_param) {
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.dummy_data_param)
}
inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::release_dummy_data_param() {
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::opencv_caffe::DummyDataParameter* temp = _impl_.dummy_data_param_;
  _impl_.dummy_data_param_ = 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 ::opencv_caffe::DummyDataParameter* V1LayerParameter::unsafe_arena_release_dummy_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.dummy_data_param)
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::opencv_caffe::DummyDataParameter* temp = _impl_.dummy_data_param_;
  _impl_.dummy_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::_internal_mutable_dummy_data_param() {
  _impl_._has_bits_[0] |= 0x00080000u;
  if (_impl_.dummy_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::DummyDataParameter>(GetArenaForAllocation());
    _impl_.dummy_data_param_ = p;
  }
  return _impl_.dummy_data_param_;
}
inline ::opencv_caffe::DummyDataParameter* V1LayerParameter::mutable_dummy_data_param() {
  ::opencv_caffe::DummyDataParameter* _msg = _internal_mutable_dummy_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.dummy_data_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_dummy_data_param(::opencv_caffe::DummyDataParameter* dummy_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dummy_data_param_;
  }
  if (dummy_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dummy_data_param);
    if (message_arena != submessage_arena) {
      dummy_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dummy_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  _impl_.dummy_data_param_ = dummy_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.dummy_data_param)
}

// optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
inline bool V1LayerParameter::_internal_has_eltwise_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.eltwise_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_eltwise_param() const {
  return _internal_has_eltwise_param();
}
inline void V1LayerParameter::clear_eltwise_param() {
  if (_impl_.eltwise_param_ != nullptr) _impl_.eltwise_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const ::opencv_caffe::EltwiseParameter& V1LayerParameter::_internal_eltwise_param() const {
  const ::opencv_caffe::EltwiseParameter* p = _impl_.eltwise_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::EltwiseParameter&>(
      ::opencv_caffe::_EltwiseParameter_default_instance_);
}
inline const ::opencv_caffe::EltwiseParameter& V1LayerParameter::eltwise_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.eltwise_param)
  return _internal_eltwise_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_eltwise_param(
    ::opencv_caffe::EltwiseParameter* eltwise_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.eltwise_param_);
  }
  _impl_.eltwise_param_ = eltwise_param;
  if (eltwise_param) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.eltwise_param)
}
inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::release_eltwise_param() {
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::opencv_caffe::EltwiseParameter* temp = _impl_.eltwise_param_;
  _impl_.eltwise_param_ = 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 ::opencv_caffe::EltwiseParameter* V1LayerParameter::unsafe_arena_release_eltwise_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.eltwise_param)
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::opencv_caffe::EltwiseParameter* temp = _impl_.eltwise_param_;
  _impl_.eltwise_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::_internal_mutable_eltwise_param() {
  _impl_._has_bits_[0] |= 0x00020000u;
  if (_impl_.eltwise_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::EltwiseParameter>(GetArenaForAllocation());
    _impl_.eltwise_param_ = p;
  }
  return _impl_.eltwise_param_;
}
inline ::opencv_caffe::EltwiseParameter* V1LayerParameter::mutable_eltwise_param() {
  ::opencv_caffe::EltwiseParameter* _msg = _internal_mutable_eltwise_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.eltwise_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_eltwise_param(::opencv_caffe::EltwiseParameter* eltwise_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.eltwise_param_;
  }
  if (eltwise_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(eltwise_param);
    if (message_arena != submessage_arena) {
      eltwise_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, eltwise_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.eltwise_param_ = eltwise_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.eltwise_param)
}

// optional .opencv_caffe.ExpParameter exp_param = 41;
inline bool V1LayerParameter::_internal_has_exp_param() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.exp_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_exp_param() const {
  return _internal_has_exp_param();
}
inline void V1LayerParameter::clear_exp_param() {
  if (_impl_.exp_param_ != nullptr) _impl_.exp_param_->Clear();
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline const ::opencv_caffe::ExpParameter& V1LayerParameter::_internal_exp_param() const {
  const ::opencv_caffe::ExpParameter* p = _impl_.exp_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ExpParameter&>(
      ::opencv_caffe::_ExpParameter_default_instance_);
}
inline const ::opencv_caffe::ExpParameter& V1LayerParameter::exp_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.exp_param)
  return _internal_exp_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_exp_param(
    ::opencv_caffe::ExpParameter* exp_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exp_param_);
  }
  _impl_.exp_param_ = exp_param;
  if (exp_param) {
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.exp_param)
}
inline ::opencv_caffe::ExpParameter* V1LayerParameter::release_exp_param() {
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::opencv_caffe::ExpParameter* temp = _impl_.exp_param_;
  _impl_.exp_param_ = 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 ::opencv_caffe::ExpParameter* V1LayerParameter::unsafe_arena_release_exp_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.exp_param)
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::opencv_caffe::ExpParameter* temp = _impl_.exp_param_;
  _impl_.exp_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ExpParameter* V1LayerParameter::_internal_mutable_exp_param() {
  _impl_._has_bits_[0] |= 0x40000000u;
  if (_impl_.exp_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ExpParameter>(GetArenaForAllocation());
    _impl_.exp_param_ = p;
  }
  return _impl_.exp_param_;
}
inline ::opencv_caffe::ExpParameter* V1LayerParameter::mutable_exp_param() {
  ::opencv_caffe::ExpParameter* _msg = _internal_mutable_exp_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.exp_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_exp_param(::opencv_caffe::ExpParameter* exp_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.exp_param_;
  }
  if (exp_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exp_param);
    if (message_arena != submessage_arena) {
      exp_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, exp_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  _impl_.exp_param_ = exp_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.exp_param)
}

// optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
inline bool V1LayerParameter::_internal_has_hdf5_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hdf5_data_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_hdf5_data_param() const {
  return _internal_has_hdf5_data_param();
}
inline void V1LayerParameter::clear_hdf5_data_param() {
  if (_impl_.hdf5_data_param_ != nullptr) _impl_.hdf5_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::opencv_caffe::HDF5DataParameter& V1LayerParameter::_internal_hdf5_data_param() const {
  const ::opencv_caffe::HDF5DataParameter* p = _impl_.hdf5_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HDF5DataParameter&>(
      ::opencv_caffe::_HDF5DataParameter_default_instance_);
}
inline const ::opencv_caffe::HDF5DataParameter& V1LayerParameter::hdf5_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hdf5_data_param)
  return _internal_hdf5_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_hdf5_data_param(
    ::opencv_caffe::HDF5DataParameter* hdf5_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hdf5_data_param_);
  }
  _impl_.hdf5_data_param_ = hdf5_data_param;
  if (hdf5_data_param) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.hdf5_data_param)
}
inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::release_hdf5_data_param() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::HDF5DataParameter* temp = _impl_.hdf5_data_param_;
  _impl_.hdf5_data_param_ = 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 ::opencv_caffe::HDF5DataParameter* V1LayerParameter::unsafe_arena_release_hdf5_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hdf5_data_param)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::HDF5DataParameter* temp = _impl_.hdf5_data_param_;
  _impl_.hdf5_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::_internal_mutable_hdf5_data_param() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.hdf5_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HDF5DataParameter>(GetArenaForAllocation());
    _impl_.hdf5_data_param_ = p;
  }
  return _impl_.hdf5_data_param_;
}
inline ::opencv_caffe::HDF5DataParameter* V1LayerParameter::mutable_hdf5_data_param() {
  ::opencv_caffe::HDF5DataParameter* _msg = _internal_mutable_hdf5_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hdf5_data_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_hdf5_data_param(::opencv_caffe::HDF5DataParameter* hdf5_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hdf5_data_param_;
  }
  if (hdf5_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hdf5_data_param);
    if (message_arena != submessage_arena) {
      hdf5_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hdf5_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.hdf5_data_param_ = hdf5_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.hdf5_data_param)
}

// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
inline bool V1LayerParameter::_internal_has_hdf5_output_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hdf5_output_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_hdf5_output_param() const {
  return _internal_has_hdf5_output_param();
}
inline void V1LayerParameter::clear_hdf5_output_param() {
  if (_impl_.hdf5_output_param_ != nullptr) _impl_.hdf5_output_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::opencv_caffe::HDF5OutputParameter& V1LayerParameter::_internal_hdf5_output_param() const {
  const ::opencv_caffe::HDF5OutputParameter* p = _impl_.hdf5_output_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HDF5OutputParameter&>(
      ::opencv_caffe::_HDF5OutputParameter_default_instance_);
}
inline const ::opencv_caffe::HDF5OutputParameter& V1LayerParameter::hdf5_output_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hdf5_output_param)
  return _internal_hdf5_output_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_hdf5_output_param(
    ::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hdf5_output_param_);
  }
  _impl_.hdf5_output_param_ = hdf5_output_param;
  if (hdf5_output_param) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.hdf5_output_param)
}
inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::release_hdf5_output_param() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::HDF5OutputParameter* temp = _impl_.hdf5_output_param_;
  _impl_.hdf5_output_param_ = 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 ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::unsafe_arena_release_hdf5_output_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hdf5_output_param)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::HDF5OutputParameter* temp = _impl_.hdf5_output_param_;
  _impl_.hdf5_output_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::_internal_mutable_hdf5_output_param() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.hdf5_output_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(GetArenaForAllocation());
    _impl_.hdf5_output_param_ = p;
  }
  return _impl_.hdf5_output_param_;
}
inline ::opencv_caffe::HDF5OutputParameter* V1LayerParameter::mutable_hdf5_output_param() {
  ::opencv_caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hdf5_output_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hdf5_output_param_;
  }
  if (hdf5_output_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hdf5_output_param);
    if (message_arena != submessage_arena) {
      hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hdf5_output_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.hdf5_output_param_ = hdf5_output_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.hdf5_output_param)
}

// optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
inline bool V1LayerParameter::_internal_has_hinge_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hinge_loss_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_hinge_loss_param() const {
  return _internal_has_hinge_loss_param();
}
inline void V1LayerParameter::clear_hinge_loss_param() {
  if (_impl_.hinge_loss_param_ != nullptr) _impl_.hinge_loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline const ::opencv_caffe::HingeLossParameter& V1LayerParameter::_internal_hinge_loss_param() const {
  const ::opencv_caffe::HingeLossParameter* p = _impl_.hinge_loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HingeLossParameter&>(
      ::opencv_caffe::_HingeLossParameter_default_instance_);
}
inline const ::opencv_caffe::HingeLossParameter& V1LayerParameter::hinge_loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.hinge_loss_param)
  return _internal_hinge_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_hinge_loss_param(
    ::opencv_caffe::HingeLossParameter* hinge_loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hinge_loss_param_);
  }
  _impl_.hinge_loss_param_ = hinge_loss_param;
  if (hinge_loss_param) {
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.hinge_loss_param)
}
inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::release_hinge_loss_param() {
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::opencv_caffe::HingeLossParameter* temp = _impl_.hinge_loss_param_;
  _impl_.hinge_loss_param_ = 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 ::opencv_caffe::HingeLossParameter* V1LayerParameter::unsafe_arena_release_hinge_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.hinge_loss_param)
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::opencv_caffe::HingeLossParameter* temp = _impl_.hinge_loss_param_;
  _impl_.hinge_loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::_internal_mutable_hinge_loss_param() {
  _impl_._has_bits_[0] |= 0x00200000u;
  if (_impl_.hinge_loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HingeLossParameter>(GetArenaForAllocation());
    _impl_.hinge_loss_param_ = p;
  }
  return _impl_.hinge_loss_param_;
}
inline ::opencv_caffe::HingeLossParameter* V1LayerParameter::mutable_hinge_loss_param() {
  ::opencv_caffe::HingeLossParameter* _msg = _internal_mutable_hinge_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.hinge_loss_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_hinge_loss_param(::opencv_caffe::HingeLossParameter* hinge_loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hinge_loss_param_;
  }
  if (hinge_loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hinge_loss_param);
    if (message_arena != submessage_arena) {
      hinge_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hinge_loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  _impl_.hinge_loss_param_ = hinge_loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.hinge_loss_param)
}

// optional .opencv_caffe.ImageDataParameter image_data_param = 15;
inline bool V1LayerParameter::_internal_has_image_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.image_data_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_image_data_param() const {
  return _internal_has_image_data_param();
}
inline void V1LayerParameter::clear_image_data_param() {
  if (_impl_.image_data_param_ != nullptr) _impl_.image_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::opencv_caffe::ImageDataParameter& V1LayerParameter::_internal_image_data_param() const {
  const ::opencv_caffe::ImageDataParameter* p = _impl_.image_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ImageDataParameter&>(
      ::opencv_caffe::_ImageDataParameter_default_instance_);
}
inline const ::opencv_caffe::ImageDataParameter& V1LayerParameter::image_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.image_data_param)
  return _internal_image_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_image_data_param(
    ::opencv_caffe::ImageDataParameter* image_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_data_param_);
  }
  _impl_.image_data_param_ = image_data_param;
  if (image_data_param) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.image_data_param)
}
inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::release_image_data_param() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::opencv_caffe::ImageDataParameter* temp = _impl_.image_data_param_;
  _impl_.image_data_param_ = 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 ::opencv_caffe::ImageDataParameter* V1LayerParameter::unsafe_arena_release_image_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.image_data_param)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::opencv_caffe::ImageDataParameter* temp = _impl_.image_data_param_;
  _impl_.image_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::_internal_mutable_image_data_param() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.image_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ImageDataParameter>(GetArenaForAllocation());
    _impl_.image_data_param_ = p;
  }
  return _impl_.image_data_param_;
}
inline ::opencv_caffe::ImageDataParameter* V1LayerParameter::mutable_image_data_param() {
  ::opencv_caffe::ImageDataParameter* _msg = _internal_mutable_image_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.image_data_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_image_data_param(::opencv_caffe::ImageDataParameter* image_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.image_data_param_;
  }
  if (image_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_data_param);
    if (message_arena != submessage_arena) {
      image_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, image_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.image_data_param_ = image_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.image_data_param)
}

// optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
inline bool V1LayerParameter::_internal_has_infogain_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.infogain_loss_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_infogain_loss_param() const {
  return _internal_has_infogain_loss_param();
}
inline void V1LayerParameter::clear_infogain_loss_param() {
  if (_impl_.infogain_loss_param_ != nullptr) _impl_.infogain_loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::opencv_caffe::InfogainLossParameter& V1LayerParameter::_internal_infogain_loss_param() const {
  const ::opencv_caffe::InfogainLossParameter* p = _impl_.infogain_loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::InfogainLossParameter&>(
      ::opencv_caffe::_InfogainLossParameter_default_instance_);
}
inline const ::opencv_caffe::InfogainLossParameter& V1LayerParameter::infogain_loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.infogain_loss_param)
  return _internal_infogain_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_infogain_loss_param(
    ::opencv_caffe::InfogainLossParameter* infogain_loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.infogain_loss_param_);
  }
  _impl_.infogain_loss_param_ = infogain_loss_param;
  if (infogain_loss_param) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.infogain_loss_param)
}
inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::release_infogain_loss_param() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::opencv_caffe::InfogainLossParameter* temp = _impl_.infogain_loss_param_;
  _impl_.infogain_loss_param_ = 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 ::opencv_caffe::InfogainLossParameter* V1LayerParameter::unsafe_arena_release_infogain_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.infogain_loss_param)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::opencv_caffe::InfogainLossParameter* temp = _impl_.infogain_loss_param_;
  _impl_.infogain_loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::_internal_mutable_infogain_loss_param() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.infogain_loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::InfogainLossParameter>(GetArenaForAllocation());
    _impl_.infogain_loss_param_ = p;
  }
  return _impl_.infogain_loss_param_;
}
inline ::opencv_caffe::InfogainLossParameter* V1LayerParameter::mutable_infogain_loss_param() {
  ::opencv_caffe::InfogainLossParameter* _msg = _internal_mutable_infogain_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.infogain_loss_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_infogain_loss_param(::opencv_caffe::InfogainLossParameter* infogain_loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.infogain_loss_param_;
  }
  if (infogain_loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(infogain_loss_param);
    if (message_arena != submessage_arena) {
      infogain_loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, infogain_loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.infogain_loss_param_ = infogain_loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.infogain_loss_param)
}

// optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
inline bool V1LayerParameter::_internal_has_inner_product_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.inner_product_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_inner_product_param() const {
  return _internal_has_inner_product_param();
}
inline void V1LayerParameter::clear_inner_product_param() {
  if (_impl_.inner_product_param_ != nullptr) _impl_.inner_product_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::opencv_caffe::InnerProductParameter& V1LayerParameter::_internal_inner_product_param() const {
  const ::opencv_caffe::InnerProductParameter* p = _impl_.inner_product_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::InnerProductParameter&>(
      ::opencv_caffe::_InnerProductParameter_default_instance_);
}
inline const ::opencv_caffe::InnerProductParameter& V1LayerParameter::inner_product_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.inner_product_param)
  return _internal_inner_product_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_inner_product_param(
    ::opencv_caffe::InnerProductParameter* inner_product_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.inner_product_param_);
  }
  _impl_.inner_product_param_ = inner_product_param;
  if (inner_product_param) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.inner_product_param)
}
inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::release_inner_product_param() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::opencv_caffe::InnerProductParameter* temp = _impl_.inner_product_param_;
  _impl_.inner_product_param_ = 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 ::opencv_caffe::InnerProductParameter* V1LayerParameter::unsafe_arena_release_inner_product_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.inner_product_param)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::opencv_caffe::InnerProductParameter* temp = _impl_.inner_product_param_;
  _impl_.inner_product_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::_internal_mutable_inner_product_param() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.inner_product_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::InnerProductParameter>(GetArenaForAllocation());
    _impl_.inner_product_param_ = p;
  }
  return _impl_.inner_product_param_;
}
inline ::opencv_caffe::InnerProductParameter* V1LayerParameter::mutable_inner_product_param() {
  ::opencv_caffe::InnerProductParameter* _msg = _internal_mutable_inner_product_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.inner_product_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_inner_product_param(::opencv_caffe::InnerProductParameter* inner_product_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.inner_product_param_;
  }
  if (inner_product_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(inner_product_param);
    if (message_arena != submessage_arena) {
      inner_product_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, inner_product_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.inner_product_param_ = inner_product_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.inner_product_param)
}

// optional .opencv_caffe.LRNParameter lrn_param = 18;
inline bool V1LayerParameter::_internal_has_lrn_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lrn_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_lrn_param() const {
  return _internal_has_lrn_param();
}
inline void V1LayerParameter::clear_lrn_param() {
  if (_impl_.lrn_param_ != nullptr) _impl_.lrn_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::opencv_caffe::LRNParameter& V1LayerParameter::_internal_lrn_param() const {
  const ::opencv_caffe::LRNParameter* p = _impl_.lrn_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::LRNParameter&>(
      ::opencv_caffe::_LRNParameter_default_instance_);
}
inline const ::opencv_caffe::LRNParameter& V1LayerParameter::lrn_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.lrn_param)
  return _internal_lrn_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_lrn_param(
    ::opencv_caffe::LRNParameter* lrn_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lrn_param_);
  }
  _impl_.lrn_param_ = lrn_param;
  if (lrn_param) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.lrn_param)
}
inline ::opencv_caffe::LRNParameter* V1LayerParameter::release_lrn_param() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::opencv_caffe::LRNParameter* temp = _impl_.lrn_param_;
  _impl_.lrn_param_ = 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 ::opencv_caffe::LRNParameter* V1LayerParameter::unsafe_arena_release_lrn_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.lrn_param)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::opencv_caffe::LRNParameter* temp = _impl_.lrn_param_;
  _impl_.lrn_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::LRNParameter* V1LayerParameter::_internal_mutable_lrn_param() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.lrn_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::LRNParameter>(GetArenaForAllocation());
    _impl_.lrn_param_ = p;
  }
  return _impl_.lrn_param_;
}
inline ::opencv_caffe::LRNParameter* V1LayerParameter::mutable_lrn_param() {
  ::opencv_caffe::LRNParameter* _msg = _internal_mutable_lrn_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.lrn_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_lrn_param(::opencv_caffe::LRNParameter* lrn_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lrn_param_;
  }
  if (lrn_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lrn_param);
    if (message_arena != submessage_arena) {
      lrn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lrn_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.lrn_param_ = lrn_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.lrn_param)
}

// optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
inline bool V1LayerParameter::_internal_has_memory_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.memory_data_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_memory_data_param() const {
  return _internal_has_memory_data_param();
}
inline void V1LayerParameter::clear_memory_data_param() {
  if (_impl_.memory_data_param_ != nullptr) _impl_.memory_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::opencv_caffe::MemoryDataParameter& V1LayerParameter::_internal_memory_data_param() const {
  const ::opencv_caffe::MemoryDataParameter* p = _impl_.memory_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::MemoryDataParameter&>(
      ::opencv_caffe::_MemoryDataParameter_default_instance_);
}
inline const ::opencv_caffe::MemoryDataParameter& V1LayerParameter::memory_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.memory_data_param)
  return _internal_memory_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_memory_data_param(
    ::opencv_caffe::MemoryDataParameter* memory_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memory_data_param_);
  }
  _impl_.memory_data_param_ = memory_data_param;
  if (memory_data_param) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.memory_data_param)
}
inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::release_memory_data_param() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::opencv_caffe::MemoryDataParameter* temp = _impl_.memory_data_param_;
  _impl_.memory_data_param_ = 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 ::opencv_caffe::MemoryDataParameter* V1LayerParameter::unsafe_arena_release_memory_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.memory_data_param)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::opencv_caffe::MemoryDataParameter* temp = _impl_.memory_data_param_;
  _impl_.memory_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::_internal_mutable_memory_data_param() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.memory_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::MemoryDataParameter>(GetArenaForAllocation());
    _impl_.memory_data_param_ = p;
  }
  return _impl_.memory_data_param_;
}
inline ::opencv_caffe::MemoryDataParameter* V1LayerParameter::mutable_memory_data_param() {
  ::opencv_caffe::MemoryDataParameter* _msg = _internal_mutable_memory_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.memory_data_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_memory_data_param(::opencv_caffe::MemoryDataParameter* memory_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.memory_data_param_;
  }
  if (memory_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memory_data_param);
    if (message_arena != submessage_arena) {
      memory_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, memory_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.memory_data_param_ = memory_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.memory_data_param)
}

// optional .opencv_caffe.MVNParameter mvn_param = 34;
inline bool V1LayerParameter::_internal_has_mvn_param() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mvn_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_mvn_param() const {
  return _internal_has_mvn_param();
}
inline void V1LayerParameter::clear_mvn_param() {
  if (_impl_.mvn_param_ != nullptr) _impl_.mvn_param_->Clear();
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline const ::opencv_caffe::MVNParameter& V1LayerParameter::_internal_mvn_param() const {
  const ::opencv_caffe::MVNParameter* p = _impl_.mvn_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::MVNParameter&>(
      ::opencv_caffe::_MVNParameter_default_instance_);
}
inline const ::opencv_caffe::MVNParameter& V1LayerParameter::mvn_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.mvn_param)
  return _internal_mvn_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_mvn_param(
    ::opencv_caffe::MVNParameter* mvn_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mvn_param_);
  }
  _impl_.mvn_param_ = mvn_param;
  if (mvn_param) {
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.mvn_param)
}
inline ::opencv_caffe::MVNParameter* V1LayerParameter::release_mvn_param() {
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::opencv_caffe::MVNParameter* temp = _impl_.mvn_param_;
  _impl_.mvn_param_ = 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 ::opencv_caffe::MVNParameter* V1LayerParameter::unsafe_arena_release_mvn_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.mvn_param)
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::opencv_caffe::MVNParameter* temp = _impl_.mvn_param_;
  _impl_.mvn_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::MVNParameter* V1LayerParameter::_internal_mutable_mvn_param() {
  _impl_._has_bits_[0] |= 0x01000000u;
  if (_impl_.mvn_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::MVNParameter>(GetArenaForAllocation());
    _impl_.mvn_param_ = p;
  }
  return _impl_.mvn_param_;
}
inline ::opencv_caffe::MVNParameter* V1LayerParameter::mutable_mvn_param() {
  ::opencv_caffe::MVNParameter* _msg = _internal_mutable_mvn_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.mvn_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_mvn_param(::opencv_caffe::MVNParameter* mvn_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.mvn_param_;
  }
  if (mvn_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mvn_param);
    if (message_arena != submessage_arena) {
      mvn_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mvn_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  _impl_.mvn_param_ = mvn_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.mvn_param)
}

// optional .opencv_caffe.PoolingParameter pooling_param = 19;
inline bool V1LayerParameter::_internal_has_pooling_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pooling_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_pooling_param() const {
  return _internal_has_pooling_param();
}
inline void V1LayerParameter::clear_pooling_param() {
  if (_impl_.pooling_param_ != nullptr) _impl_.pooling_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::opencv_caffe::PoolingParameter& V1LayerParameter::_internal_pooling_param() const {
  const ::opencv_caffe::PoolingParameter* p = _impl_.pooling_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PoolingParameter&>(
      ::opencv_caffe::_PoolingParameter_default_instance_);
}
inline const ::opencv_caffe::PoolingParameter& V1LayerParameter::pooling_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.pooling_param)
  return _internal_pooling_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_pooling_param(
    ::opencv_caffe::PoolingParameter* pooling_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pooling_param_);
  }
  _impl_.pooling_param_ = pooling_param;
  if (pooling_param) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.pooling_param)
}
inline ::opencv_caffe::PoolingParameter* V1LayerParameter::release_pooling_param() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::opencv_caffe::PoolingParameter* temp = _impl_.pooling_param_;
  _impl_.pooling_param_ = 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 ::opencv_caffe::PoolingParameter* V1LayerParameter::unsafe_arena_release_pooling_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.pooling_param)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::opencv_caffe::PoolingParameter* temp = _impl_.pooling_param_;
  _impl_.pooling_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PoolingParameter* V1LayerParameter::_internal_mutable_pooling_param() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.pooling_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PoolingParameter>(GetArenaForAllocation());
    _impl_.pooling_param_ = p;
  }
  return _impl_.pooling_param_;
}
inline ::opencv_caffe::PoolingParameter* V1LayerParameter::mutable_pooling_param() {
  ::opencv_caffe::PoolingParameter* _msg = _internal_mutable_pooling_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.pooling_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_pooling_param(::opencv_caffe::PoolingParameter* pooling_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pooling_param_;
  }
  if (pooling_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pooling_param);
    if (message_arena != submessage_arena) {
      pooling_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pooling_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.pooling_param_ = pooling_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.pooling_param)
}

// optional .opencv_caffe.PowerParameter power_param = 21;
inline bool V1LayerParameter::_internal_has_power_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.power_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_power_param() const {
  return _internal_has_power_param();
}
inline void V1LayerParameter::clear_power_param() {
  if (_impl_.power_param_ != nullptr) _impl_.power_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::opencv_caffe::PowerParameter& V1LayerParameter::_internal_power_param() const {
  const ::opencv_caffe::PowerParameter* p = _impl_.power_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::PowerParameter&>(
      ::opencv_caffe::_PowerParameter_default_instance_);
}
inline const ::opencv_caffe::PowerParameter& V1LayerParameter::power_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.power_param)
  return _internal_power_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_power_param(
    ::opencv_caffe::PowerParameter* power_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.power_param_);
  }
  _impl_.power_param_ = power_param;
  if (power_param) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.power_param)
}
inline ::opencv_caffe::PowerParameter* V1LayerParameter::release_power_param() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::opencv_caffe::PowerParameter* temp = _impl_.power_param_;
  _impl_.power_param_ = 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 ::opencv_caffe::PowerParameter* V1LayerParameter::unsafe_arena_release_power_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.power_param)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::opencv_caffe::PowerParameter* temp = _impl_.power_param_;
  _impl_.power_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::PowerParameter* V1LayerParameter::_internal_mutable_power_param() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.power_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::PowerParameter>(GetArenaForAllocation());
    _impl_.power_param_ = p;
  }
  return _impl_.power_param_;
}
inline ::opencv_caffe::PowerParameter* V1LayerParameter::mutable_power_param() {
  ::opencv_caffe::PowerParameter* _msg = _internal_mutable_power_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.power_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_power_param(::opencv_caffe::PowerParameter* power_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.power_param_;
  }
  if (power_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(power_param);
    if (message_arena != submessage_arena) {
      power_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, power_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.power_param_ = power_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.power_param)
}

// optional .opencv_caffe.ReLUParameter relu_param = 30;
inline bool V1LayerParameter::_internal_has_relu_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.relu_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_relu_param() const {
  return _internal_has_relu_param();
}
inline void V1LayerParameter::clear_relu_param() {
  if (_impl_.relu_param_ != nullptr) _impl_.relu_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline const ::opencv_caffe::ReLUParameter& V1LayerParameter::_internal_relu_param() const {
  const ::opencv_caffe::ReLUParameter* p = _impl_.relu_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ReLUParameter&>(
      ::opencv_caffe::_ReLUParameter_default_instance_);
}
inline const ::opencv_caffe::ReLUParameter& V1LayerParameter::relu_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.relu_param)
  return _internal_relu_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_relu_param(
    ::opencv_caffe::ReLUParameter* relu_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.relu_param_);
  }
  _impl_.relu_param_ = relu_param;
  if (relu_param) {
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.relu_param)
}
inline ::opencv_caffe::ReLUParameter* V1LayerParameter::release_relu_param() {
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::opencv_caffe::ReLUParameter* temp = _impl_.relu_param_;
  _impl_.relu_param_ = 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 ::opencv_caffe::ReLUParameter* V1LayerParameter::unsafe_arena_release_relu_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.relu_param)
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::opencv_caffe::ReLUParameter* temp = _impl_.relu_param_;
  _impl_.relu_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ReLUParameter* V1LayerParameter::_internal_mutable_relu_param() {
  _impl_._has_bits_[0] |= 0x00400000u;
  if (_impl_.relu_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ReLUParameter>(GetArenaForAllocation());
    _impl_.relu_param_ = p;
  }
  return _impl_.relu_param_;
}
inline ::opencv_caffe::ReLUParameter* V1LayerParameter::mutable_relu_param() {
  ::opencv_caffe::ReLUParameter* _msg = _internal_mutable_relu_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.relu_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_relu_param(::opencv_caffe::ReLUParameter* relu_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.relu_param_;
  }
  if (relu_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(relu_param);
    if (message_arena != submessage_arena) {
      relu_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, relu_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  _impl_.relu_param_ = relu_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.relu_param)
}

// optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
inline bool V1LayerParameter::_internal_has_sigmoid_param() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sigmoid_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_sigmoid_param() const {
  return _internal_has_sigmoid_param();
}
inline void V1LayerParameter::clear_sigmoid_param() {
  if (_impl_.sigmoid_param_ != nullptr) _impl_.sigmoid_param_->Clear();
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline const ::opencv_caffe::SigmoidParameter& V1LayerParameter::_internal_sigmoid_param() const {
  const ::opencv_caffe::SigmoidParameter* p = _impl_.sigmoid_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SigmoidParameter&>(
      ::opencv_caffe::_SigmoidParameter_default_instance_);
}
inline const ::opencv_caffe::SigmoidParameter& V1LayerParameter::sigmoid_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.sigmoid_param)
  return _internal_sigmoid_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_sigmoid_param(
    ::opencv_caffe::SigmoidParameter* sigmoid_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sigmoid_param_);
  }
  _impl_.sigmoid_param_ = sigmoid_param;
  if (sigmoid_param) {
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.sigmoid_param)
}
inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::release_sigmoid_param() {
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::opencv_caffe::SigmoidParameter* temp = _impl_.sigmoid_param_;
  _impl_.sigmoid_param_ = 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 ::opencv_caffe::SigmoidParameter* V1LayerParameter::unsafe_arena_release_sigmoid_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.sigmoid_param)
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::opencv_caffe::SigmoidParameter* temp = _impl_.sigmoid_param_;
  _impl_.sigmoid_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::_internal_mutable_sigmoid_param() {
  _impl_._has_bits_[0] |= 0x08000000u;
  if (_impl_.sigmoid_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SigmoidParameter>(GetArenaForAllocation());
    _impl_.sigmoid_param_ = p;
  }
  return _impl_.sigmoid_param_;
}
inline ::opencv_caffe::SigmoidParameter* V1LayerParameter::mutable_sigmoid_param() {
  ::opencv_caffe::SigmoidParameter* _msg = _internal_mutable_sigmoid_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.sigmoid_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_sigmoid_param(::opencv_caffe::SigmoidParameter* sigmoid_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sigmoid_param_;
  }
  if (sigmoid_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sigmoid_param);
    if (message_arena != submessage_arena) {
      sigmoid_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sigmoid_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  _impl_.sigmoid_param_ = sigmoid_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.sigmoid_param)
}

// optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
inline bool V1LayerParameter::_internal_has_softmax_param() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.softmax_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_softmax_param() const {
  return _internal_has_softmax_param();
}
inline void V1LayerParameter::clear_softmax_param() {
  if (_impl_.softmax_param_ != nullptr) _impl_.softmax_param_->Clear();
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline const ::opencv_caffe::SoftmaxParameter& V1LayerParameter::_internal_softmax_param() const {
  const ::opencv_caffe::SoftmaxParameter* p = _impl_.softmax_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SoftmaxParameter&>(
      ::opencv_caffe::_SoftmaxParameter_default_instance_);
}
inline const ::opencv_caffe::SoftmaxParameter& V1LayerParameter::softmax_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.softmax_param)
  return _internal_softmax_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_softmax_param(
    ::opencv_caffe::SoftmaxParameter* softmax_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.softmax_param_);
  }
  _impl_.softmax_param_ = softmax_param;
  if (softmax_param) {
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.softmax_param)
}
inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::release_softmax_param() {
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::opencv_caffe::SoftmaxParameter* temp = _impl_.softmax_param_;
  _impl_.softmax_param_ = 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 ::opencv_caffe::SoftmaxParameter* V1LayerParameter::unsafe_arena_release_softmax_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.softmax_param)
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::opencv_caffe::SoftmaxParameter* temp = _impl_.softmax_param_;
  _impl_.softmax_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::_internal_mutable_softmax_param() {
  _impl_._has_bits_[0] |= 0x10000000u;
  if (_impl_.softmax_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SoftmaxParameter>(GetArenaForAllocation());
    _impl_.softmax_param_ = p;
  }
  return _impl_.softmax_param_;
}
inline ::opencv_caffe::SoftmaxParameter* V1LayerParameter::mutable_softmax_param() {
  ::opencv_caffe::SoftmaxParameter* _msg = _internal_mutable_softmax_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.softmax_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_softmax_param(::opencv_caffe::SoftmaxParameter* softmax_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.softmax_param_;
  }
  if (softmax_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(softmax_param);
    if (message_arena != submessage_arena) {
      softmax_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, softmax_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  _impl_.softmax_param_ = softmax_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.softmax_param)
}

// optional .opencv_caffe.SliceParameter slice_param = 31;
inline bool V1LayerParameter::_internal_has_slice_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.slice_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_slice_param() const {
  return _internal_has_slice_param();
}
inline void V1LayerParameter::clear_slice_param() {
  if (_impl_.slice_param_ != nullptr) _impl_.slice_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline const ::opencv_caffe::SliceParameter& V1LayerParameter::_internal_slice_param() const {
  const ::opencv_caffe::SliceParameter* p = _impl_.slice_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::SliceParameter&>(
      ::opencv_caffe::_SliceParameter_default_instance_);
}
inline const ::opencv_caffe::SliceParameter& V1LayerParameter::slice_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.slice_param)
  return _internal_slice_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_slice_param(
    ::opencv_caffe::SliceParameter* slice_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.slice_param_);
  }
  _impl_.slice_param_ = slice_param;
  if (slice_param) {
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.slice_param)
}
inline ::opencv_caffe::SliceParameter* V1LayerParameter::release_slice_param() {
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::opencv_caffe::SliceParameter* temp = _impl_.slice_param_;
  _impl_.slice_param_ = 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 ::opencv_caffe::SliceParameter* V1LayerParameter::unsafe_arena_release_slice_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.slice_param)
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::opencv_caffe::SliceParameter* temp = _impl_.slice_param_;
  _impl_.slice_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::SliceParameter* V1LayerParameter::_internal_mutable_slice_param() {
  _impl_._has_bits_[0] |= 0x00800000u;
  if (_impl_.slice_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::SliceParameter>(GetArenaForAllocation());
    _impl_.slice_param_ = p;
  }
  return _impl_.slice_param_;
}
inline ::opencv_caffe::SliceParameter* V1LayerParameter::mutable_slice_param() {
  ::opencv_caffe::SliceParameter* _msg = _internal_mutable_slice_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.slice_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_slice_param(::opencv_caffe::SliceParameter* slice_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.slice_param_;
  }
  if (slice_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(slice_param);
    if (message_arena != submessage_arena) {
      slice_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, slice_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  _impl_.slice_param_ = slice_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.slice_param)
}

// optional .opencv_caffe.TanHParameter tanh_param = 37;
inline bool V1LayerParameter::_internal_has_tanh_param() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tanh_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_tanh_param() const {
  return _internal_has_tanh_param();
}
inline void V1LayerParameter::clear_tanh_param() {
  if (_impl_.tanh_param_ != nullptr) _impl_.tanh_param_->Clear();
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline const ::opencv_caffe::TanHParameter& V1LayerParameter::_internal_tanh_param() const {
  const ::opencv_caffe::TanHParameter* p = _impl_.tanh_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::TanHParameter&>(
      ::opencv_caffe::_TanHParameter_default_instance_);
}
inline const ::opencv_caffe::TanHParameter& V1LayerParameter::tanh_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.tanh_param)
  return _internal_tanh_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_tanh_param(
    ::opencv_caffe::TanHParameter* tanh_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tanh_param_);
  }
  _impl_.tanh_param_ = tanh_param;
  if (tanh_param) {
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.tanh_param)
}
inline ::opencv_caffe::TanHParameter* V1LayerParameter::release_tanh_param() {
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::opencv_caffe::TanHParameter* temp = _impl_.tanh_param_;
  _impl_.tanh_param_ = 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 ::opencv_caffe::TanHParameter* V1LayerParameter::unsafe_arena_release_tanh_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.tanh_param)
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::opencv_caffe::TanHParameter* temp = _impl_.tanh_param_;
  _impl_.tanh_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::TanHParameter* V1LayerParameter::_internal_mutable_tanh_param() {
  _impl_._has_bits_[0] |= 0x04000000u;
  if (_impl_.tanh_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::TanHParameter>(GetArenaForAllocation());
    _impl_.tanh_param_ = p;
  }
  return _impl_.tanh_param_;
}
inline ::opencv_caffe::TanHParameter* V1LayerParameter::mutable_tanh_param() {
  ::opencv_caffe::TanHParameter* _msg = _internal_mutable_tanh_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.tanh_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_tanh_param(::opencv_caffe::TanHParameter* tanh_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.tanh_param_;
  }
  if (tanh_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tanh_param);
    if (message_arena != submessage_arena) {
      tanh_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tanh_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  _impl_.tanh_param_ = tanh_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.tanh_param)
}

// optional .opencv_caffe.ThresholdParameter threshold_param = 25;
inline bool V1LayerParameter::_internal_has_threshold_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.threshold_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_threshold_param() const {
  return _internal_has_threshold_param();
}
inline void V1LayerParameter::clear_threshold_param() {
  if (_impl_.threshold_param_ != nullptr) _impl_.threshold_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const ::opencv_caffe::ThresholdParameter& V1LayerParameter::_internal_threshold_param() const {
  const ::opencv_caffe::ThresholdParameter* p = _impl_.threshold_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::ThresholdParameter&>(
      ::opencv_caffe::_ThresholdParameter_default_instance_);
}
inline const ::opencv_caffe::ThresholdParameter& V1LayerParameter::threshold_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.threshold_param)
  return _internal_threshold_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_threshold_param(
    ::opencv_caffe::ThresholdParameter* threshold_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threshold_param_);
  }
  _impl_.threshold_param_ = threshold_param;
  if (threshold_param) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.threshold_param)
}
inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::release_threshold_param() {
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::opencv_caffe::ThresholdParameter* temp = _impl_.threshold_param_;
  _impl_.threshold_param_ = 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 ::opencv_caffe::ThresholdParameter* V1LayerParameter::unsafe_arena_release_threshold_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.threshold_param)
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::opencv_caffe::ThresholdParameter* temp = _impl_.threshold_param_;
  _impl_.threshold_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::_internal_mutable_threshold_param() {
  _impl_._has_bits_[0] |= 0x00040000u;
  if (_impl_.threshold_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::ThresholdParameter>(GetArenaForAllocation());
    _impl_.threshold_param_ = p;
  }
  return _impl_.threshold_param_;
}
inline ::opencv_caffe::ThresholdParameter* V1LayerParameter::mutable_threshold_param() {
  ::opencv_caffe::ThresholdParameter* _msg = _internal_mutable_threshold_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.threshold_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_threshold_param(::opencv_caffe::ThresholdParameter* threshold_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.threshold_param_;
  }
  if (threshold_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threshold_param);
    if (message_arena != submessage_arena) {
      threshold_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, threshold_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.threshold_param_ = threshold_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.threshold_param)
}

// optional .opencv_caffe.WindowDataParameter window_data_param = 20;
inline bool V1LayerParameter::_internal_has_window_data_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.window_data_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_window_data_param() const {
  return _internal_has_window_data_param();
}
inline void V1LayerParameter::clear_window_data_param() {
  if (_impl_.window_data_param_ != nullptr) _impl_.window_data_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::opencv_caffe::WindowDataParameter& V1LayerParameter::_internal_window_data_param() const {
  const ::opencv_caffe::WindowDataParameter* p = _impl_.window_data_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::WindowDataParameter&>(
      ::opencv_caffe::_WindowDataParameter_default_instance_);
}
inline const ::opencv_caffe::WindowDataParameter& V1LayerParameter::window_data_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.window_data_param)
  return _internal_window_data_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_window_data_param(
    ::opencv_caffe::WindowDataParameter* window_data_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.window_data_param_);
  }
  _impl_.window_data_param_ = window_data_param;
  if (window_data_param) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.window_data_param)
}
inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::release_window_data_param() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::opencv_caffe::WindowDataParameter* temp = _impl_.window_data_param_;
  _impl_.window_data_param_ = 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 ::opencv_caffe::WindowDataParameter* V1LayerParameter::unsafe_arena_release_window_data_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.window_data_param)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::opencv_caffe::WindowDataParameter* temp = _impl_.window_data_param_;
  _impl_.window_data_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::_internal_mutable_window_data_param() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.window_data_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::WindowDataParameter>(GetArenaForAllocation());
    _impl_.window_data_param_ = p;
  }
  return _impl_.window_data_param_;
}
inline ::opencv_caffe::WindowDataParameter* V1LayerParameter::mutable_window_data_param() {
  ::opencv_caffe::WindowDataParameter* _msg = _internal_mutable_window_data_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.window_data_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_window_data_param(::opencv_caffe::WindowDataParameter* window_data_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.window_data_param_;
  }
  if (window_data_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(window_data_param);
    if (message_arena != submessage_arena) {
      window_data_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, window_data_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.window_data_param_ = window_data_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.window_data_param)
}

// optional .opencv_caffe.TransformationParameter transform_param = 36;
inline bool V1LayerParameter::_internal_has_transform_param() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.transform_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_transform_param() const {
  return _internal_has_transform_param();
}
inline void V1LayerParameter::clear_transform_param() {
  if (_impl_.transform_param_ != nullptr) _impl_.transform_param_->Clear();
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline const ::opencv_caffe::TransformationParameter& V1LayerParameter::_internal_transform_param() const {
  const ::opencv_caffe::TransformationParameter* p = _impl_.transform_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::TransformationParameter&>(
      ::opencv_caffe::_TransformationParameter_default_instance_);
}
inline const ::opencv_caffe::TransformationParameter& V1LayerParameter::transform_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.transform_param)
  return _internal_transform_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_transform_param(
    ::opencv_caffe::TransformationParameter* transform_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transform_param_);
  }
  _impl_.transform_param_ = transform_param;
  if (transform_param) {
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.transform_param)
}
inline ::opencv_caffe::TransformationParameter* V1LayerParameter::release_transform_param() {
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::opencv_caffe::TransformationParameter* temp = _impl_.transform_param_;
  _impl_.transform_param_ = 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 ::opencv_caffe::TransformationParameter* V1LayerParameter::unsafe_arena_release_transform_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.transform_param)
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::opencv_caffe::TransformationParameter* temp = _impl_.transform_param_;
  _impl_.transform_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::TransformationParameter* V1LayerParameter::_internal_mutable_transform_param() {
  _impl_._has_bits_[0] |= 0x02000000u;
  if (_impl_.transform_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::TransformationParameter>(GetArenaForAllocation());
    _impl_.transform_param_ = p;
  }
  return _impl_.transform_param_;
}
inline ::opencv_caffe::TransformationParameter* V1LayerParameter::mutable_transform_param() {
  ::opencv_caffe::TransformationParameter* _msg = _internal_mutable_transform_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.transform_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_transform_param(::opencv_caffe::TransformationParameter* transform_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.transform_param_;
  }
  if (transform_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(transform_param);
    if (message_arena != submessage_arena) {
      transform_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, transform_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  _impl_.transform_param_ = transform_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.transform_param)
}

// optional .opencv_caffe.LossParameter loss_param = 42;
inline bool V1LayerParameter::_internal_has_loss_param() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.loss_param_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_loss_param() const {
  return _internal_has_loss_param();
}
inline void V1LayerParameter::clear_loss_param() {
  if (_impl_.loss_param_ != nullptr) _impl_.loss_param_->Clear();
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline const ::opencv_caffe::LossParameter& V1LayerParameter::_internal_loss_param() const {
  const ::opencv_caffe::LossParameter* p = _impl_.loss_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::LossParameter&>(
      ::opencv_caffe::_LossParameter_default_instance_);
}
inline const ::opencv_caffe::LossParameter& V1LayerParameter::loss_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.loss_param)
  return _internal_loss_param();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_loss_param(
    ::opencv_caffe::LossParameter* loss_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.loss_param_);
  }
  _impl_.loss_param_ = loss_param;
  if (loss_param) {
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.loss_param)
}
inline ::opencv_caffe::LossParameter* V1LayerParameter::release_loss_param() {
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::opencv_caffe::LossParameter* temp = _impl_.loss_param_;
  _impl_.loss_param_ = 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 ::opencv_caffe::LossParameter* V1LayerParameter::unsafe_arena_release_loss_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.loss_param)
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::opencv_caffe::LossParameter* temp = _impl_.loss_param_;
  _impl_.loss_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::LossParameter* V1LayerParameter::_internal_mutable_loss_param() {
  _impl_._has_bits_[0] |= 0x80000000u;
  if (_impl_.loss_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::LossParameter>(GetArenaForAllocation());
    _impl_.loss_param_ = p;
  }
  return _impl_.loss_param_;
}
inline ::opencv_caffe::LossParameter* V1LayerParameter::mutable_loss_param() {
  ::opencv_caffe::LossParameter* _msg = _internal_mutable_loss_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.loss_param)
  return _msg;
}
inline void V1LayerParameter::set_allocated_loss_param(::opencv_caffe::LossParameter* loss_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.loss_param_;
  }
  if (loss_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(loss_param);
    if (message_arena != submessage_arena) {
      loss_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loss_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  _impl_.loss_param_ = loss_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.loss_param)
}

// optional .opencv_caffe.V0LayerParameter layer = 1;
inline bool V1LayerParameter::_internal_has_layer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.layer_ != nullptr);
  return value;
}
inline bool V1LayerParameter::has_layer() const {
  return _internal_has_layer();
}
inline void V1LayerParameter::clear_layer() {
  if (_impl_.layer_ != nullptr) _impl_.layer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::opencv_caffe::V0LayerParameter& V1LayerParameter::_internal_layer() const {
  const ::opencv_caffe::V0LayerParameter* p = _impl_.layer_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::V0LayerParameter&>(
      ::opencv_caffe::_V0LayerParameter_default_instance_);
}
inline const ::opencv_caffe::V0LayerParameter& V1LayerParameter::layer() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V1LayerParameter.layer)
  return _internal_layer();
}
inline void V1LayerParameter::unsafe_arena_set_allocated_layer(
    ::opencv_caffe::V0LayerParameter* layer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.layer_);
  }
  _impl_.layer_ = layer;
  if (layer) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V1LayerParameter.layer)
}
inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::release_layer() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::V0LayerParameter* temp = _impl_.layer_;
  _impl_.layer_ = 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 ::opencv_caffe::V0LayerParameter* V1LayerParameter::unsafe_arena_release_layer() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V1LayerParameter.layer)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::opencv_caffe::V0LayerParameter* temp = _impl_.layer_;
  _impl_.layer_ = nullptr;
  return temp;
}
inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::_internal_mutable_layer() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.layer_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::V0LayerParameter>(GetArenaForAllocation());
    _impl_.layer_ = p;
  }
  return _impl_.layer_;
}
inline ::opencv_caffe::V0LayerParameter* V1LayerParameter::mutable_layer() {
  ::opencv_caffe::V0LayerParameter* _msg = _internal_mutable_layer();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V1LayerParameter.layer)
  return _msg;
}
inline void V1LayerParameter::set_allocated_layer(::opencv_caffe::V0LayerParameter* layer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.layer_;
  }
  if (layer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(layer);
    if (message_arena != submessage_arena) {
      layer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, layer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.layer_ = layer;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V1LayerParameter.layer)
}

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

// V0LayerParameter

// optional string name = 1;
inline bool V0LayerParameter::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool V0LayerParameter::has_name() const {
  return _internal_has_name();
}
inline void V0LayerParameter::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& V0LayerParameter::name() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.name)
}
inline std::string* V0LayerParameter::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.name)
  return _s;
}
inline const std::string& V0LayerParameter::_internal_name() const {
  return _impl_.name_.Get();
}
inline void V0LayerParameter::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_name() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void V0LayerParameter::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.name)
}

// optional string type = 2;
inline bool V0LayerParameter::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool V0LayerParameter::has_type() const {
  return _internal_has_type();
}
inline void V0LayerParameter::clear_type() {
  _impl_.type_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& V0LayerParameter::type() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.type)
}
inline std::string* V0LayerParameter::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.type)
  return _s;
}
inline const std::string& V0LayerParameter::_internal_type() const {
  return _impl_.type_.Get();
}
inline void V0LayerParameter::_internal_set_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_.Set(value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_type() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.type_.Mutable(GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_type() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.type_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void V0LayerParameter::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.type)
}

// optional uint32 num_output = 3;
inline bool V0LayerParameter::_internal_has_num_output() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool V0LayerParameter::has_num_output() const {
  return _internal_has_num_output();
}
inline void V0LayerParameter::clear_num_output() {
  _impl_.num_output_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t V0LayerParameter::_internal_num_output() const {
  return _impl_.num_output_;
}
inline uint32_t V0LayerParameter::num_output() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.num_output)
  return _internal_num_output();
}
inline void V0LayerParameter::_internal_set_num_output(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.num_output_ = value;
}
inline void V0LayerParameter::set_num_output(uint32_t value) {
  _internal_set_num_output(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.num_output)
}

// optional bool biasterm = 4 [default = true];
inline bool V0LayerParameter::_internal_has_biasterm() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_biasterm() const {
  return _internal_has_biasterm();
}
inline void V0LayerParameter::clear_biasterm() {
  _impl_.biasterm_ = true;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline bool V0LayerParameter::_internal_biasterm() const {
  return _impl_.biasterm_;
}
inline bool V0LayerParameter::biasterm() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.biasterm)
  return _internal_biasterm();
}
inline void V0LayerParameter::_internal_set_biasterm(bool value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.biasterm_ = value;
}
inline void V0LayerParameter::set_biasterm(bool value) {
  _internal_set_biasterm(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.biasterm)
}

// optional .opencv_caffe.FillerParameter weight_filler = 5;
inline bool V0LayerParameter::_internal_has_weight_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.weight_filler_ != nullptr);
  return value;
}
inline bool V0LayerParameter::has_weight_filler() const {
  return _internal_has_weight_filler();
}
inline void V0LayerParameter::clear_weight_filler() {
  if (_impl_.weight_filler_ != nullptr) _impl_.weight_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::opencv_caffe::FillerParameter& V0LayerParameter::_internal_weight_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.weight_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& V0LayerParameter::weight_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.weight_filler)
  return _internal_weight_filler();
}
inline void V0LayerParameter::unsafe_arena_set_allocated_weight_filler(
    ::opencv_caffe::FillerParameter* weight_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.weight_filler_);
  }
  _impl_.weight_filler_ = weight_filler;
  if (weight_filler) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V0LayerParameter.weight_filler)
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::release_weight_filler() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = 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 ::opencv_caffe::FillerParameter* V0LayerParameter::unsafe_arena_release_weight_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.weight_filler)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::opencv_caffe::FillerParameter* temp = _impl_.weight_filler_;
  _impl_.weight_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::_internal_mutable_weight_filler() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.weight_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.weight_filler_ = p;
  }
  return _impl_.weight_filler_;
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_weight_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.weight_filler)
  return _msg;
}
inline void V0LayerParameter::set_allocated_weight_filler(::opencv_caffe::FillerParameter* weight_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.weight_filler_;
  }
  if (weight_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(weight_filler);
    if (message_arena != submessage_arena) {
      weight_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, weight_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.weight_filler_ = weight_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.weight_filler)
}

// optional .opencv_caffe.FillerParameter bias_filler = 6;
inline bool V0LayerParameter::_internal_has_bias_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bias_filler_ != nullptr);
  return value;
}
inline bool V0LayerParameter::has_bias_filler() const {
  return _internal_has_bias_filler();
}
inline void V0LayerParameter::clear_bias_filler() {
  if (_impl_.bias_filler_ != nullptr) _impl_.bias_filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::opencv_caffe::FillerParameter& V0LayerParameter::_internal_bias_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.bias_filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& V0LayerParameter::bias_filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.bias_filler)
  return _internal_bias_filler();
}
inline void V0LayerParameter::unsafe_arena_set_allocated_bias_filler(
    ::opencv_caffe::FillerParameter* bias_filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bias_filler_);
  }
  _impl_.bias_filler_ = bias_filler;
  if (bias_filler) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V0LayerParameter.bias_filler)
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::release_bias_filler() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = 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 ::opencv_caffe::FillerParameter* V0LayerParameter::unsafe_arena_release_bias_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.bias_filler)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::opencv_caffe::FillerParameter* temp = _impl_.bias_filler_;
  _impl_.bias_filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::_internal_mutable_bias_filler() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.bias_filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.bias_filler_ = p;
  }
  return _impl_.bias_filler_;
}
inline ::opencv_caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_bias_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.bias_filler)
  return _msg;
}
inline void V0LayerParameter::set_allocated_bias_filler(::opencv_caffe::FillerParameter* bias_filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bias_filler_;
  }
  if (bias_filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bias_filler);
    if (message_arena != submessage_arena) {
      bias_filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bias_filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.bias_filler_ = bias_filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.bias_filler)
}

// optional uint32 pad = 7 [default = 0];
inline bool V0LayerParameter::_internal_has_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool V0LayerParameter::has_pad() const {
  return _internal_has_pad();
}
inline void V0LayerParameter::clear_pad() {
  _impl_.pad_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t V0LayerParameter::_internal_pad() const {
  return _impl_.pad_;
}
inline uint32_t V0LayerParameter::pad() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.pad)
  return _internal_pad();
}
inline void V0LayerParameter::_internal_set_pad(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.pad_ = value;
}
inline void V0LayerParameter::set_pad(uint32_t value) {
  _internal_set_pad(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.pad)
}

// optional uint32 kernelsize = 8;
inline bool V0LayerParameter::_internal_has_kernelsize() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool V0LayerParameter::has_kernelsize() const {
  return _internal_has_kernelsize();
}
inline void V0LayerParameter::clear_kernelsize() {
  _impl_.kernelsize_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t V0LayerParameter::_internal_kernelsize() const {
  return _impl_.kernelsize_;
}
inline uint32_t V0LayerParameter::kernelsize() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.kernelsize)
  return _internal_kernelsize();
}
inline void V0LayerParameter::_internal_set_kernelsize(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.kernelsize_ = value;
}
inline void V0LayerParameter::set_kernelsize(uint32_t value) {
  _internal_set_kernelsize(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.kernelsize)
}

// optional uint32 group = 9 [default = 1];
inline bool V0LayerParameter::_internal_has_group() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_group() const {
  return _internal_has_group();
}
inline void V0LayerParameter::clear_group() {
  _impl_.group_ = 1u;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline uint32_t V0LayerParameter::_internal_group() const {
  return _impl_.group_;
}
inline uint32_t V0LayerParameter::group() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.group)
  return _internal_group();
}
inline void V0LayerParameter::_internal_set_group(uint32_t value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.group_ = value;
}
inline void V0LayerParameter::set_group(uint32_t value) {
  _internal_set_group(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.group)
}

// optional uint32 stride = 10 [default = 1];
inline bool V0LayerParameter::_internal_has_stride() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_stride() const {
  return _internal_has_stride();
}
inline void V0LayerParameter::clear_stride() {
  _impl_.stride_ = 1u;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline uint32_t V0LayerParameter::_internal_stride() const {
  return _impl_.stride_;
}
inline uint32_t V0LayerParameter::stride() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.stride)
  return _internal_stride();
}
inline void V0LayerParameter::_internal_set_stride(uint32_t value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.stride_ = value;
}
inline void V0LayerParameter::set_stride(uint32_t value) {
  _internal_set_stride(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.stride)
}

// optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
inline bool V0LayerParameter::_internal_has_pool() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool V0LayerParameter::has_pool() const {
  return _internal_has_pool();
}
inline void V0LayerParameter::clear_pool() {
  _impl_.pool_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::opencv_caffe::V0LayerParameter_PoolMethod V0LayerParameter::_internal_pool() const {
  return static_cast< ::opencv_caffe::V0LayerParameter_PoolMethod >(_impl_.pool_);
}
inline ::opencv_caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.pool)
  return _internal_pool();
}
inline void V0LayerParameter::_internal_set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value) {
  assert(::opencv_caffe::V0LayerParameter_PoolMethod_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.pool_ = value;
}
inline void V0LayerParameter::set_pool(::opencv_caffe::V0LayerParameter_PoolMethod value) {
  _internal_set_pool(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.pool)
}

// optional float dropout_ratio = 12 [default = 0.5];
inline bool V0LayerParameter::_internal_has_dropout_ratio() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_dropout_ratio() const {
  return _internal_has_dropout_ratio();
}
inline void V0LayerParameter::clear_dropout_ratio() {
  _impl_.dropout_ratio_ = 0.5f;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline float V0LayerParameter::_internal_dropout_ratio() const {
  return _impl_.dropout_ratio_;
}
inline float V0LayerParameter::dropout_ratio() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.dropout_ratio)
  return _internal_dropout_ratio();
}
inline void V0LayerParameter::_internal_set_dropout_ratio(float value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.dropout_ratio_ = value;
}
inline void V0LayerParameter::set_dropout_ratio(float value) {
  _internal_set_dropout_ratio(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.dropout_ratio)
}

// optional uint32 local_size = 13 [default = 5];
inline bool V0LayerParameter::_internal_has_local_size() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_local_size() const {
  return _internal_has_local_size();
}
inline void V0LayerParameter::clear_local_size() {
  _impl_.local_size_ = 5u;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline uint32_t V0LayerParameter::_internal_local_size() const {
  return _impl_.local_size_;
}
inline uint32_t V0LayerParameter::local_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.local_size)
  return _internal_local_size();
}
inline void V0LayerParameter::_internal_set_local_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.local_size_ = value;
}
inline void V0LayerParameter::set_local_size(uint32_t value) {
  _internal_set_local_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.local_size)
}

// optional float alpha = 14 [default = 1];
inline bool V0LayerParameter::_internal_has_alpha() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_alpha() const {
  return _internal_has_alpha();
}
inline void V0LayerParameter::clear_alpha() {
  _impl_.alpha_ = 1;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline float V0LayerParameter::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float V0LayerParameter::alpha() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.alpha)
  return _internal_alpha();
}
inline void V0LayerParameter::_internal_set_alpha(float value) {
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.alpha_ = value;
}
inline void V0LayerParameter::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.alpha)
}

// optional float beta = 15 [default = 0.75];
inline bool V0LayerParameter::_internal_has_beta() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_beta() const {
  return _internal_has_beta();
}
inline void V0LayerParameter::clear_beta() {
  _impl_.beta_ = 0.75f;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline float V0LayerParameter::_internal_beta() const {
  return _impl_.beta_;
}
inline float V0LayerParameter::beta() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.beta)
  return _internal_beta();
}
inline void V0LayerParameter::_internal_set_beta(float value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.beta_ = value;
}
inline void V0LayerParameter::set_beta(float value) {
  _internal_set_beta(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.beta)
}

// optional float k = 22 [default = 1];
inline bool V0LayerParameter::_internal_has_k() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_k() const {
  return _internal_has_k();
}
inline void V0LayerParameter::clear_k() {
  _impl_.k_ = 1;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline float V0LayerParameter::_internal_k() const {
  return _impl_.k_;
}
inline float V0LayerParameter::k() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.k)
  return _internal_k();
}
inline void V0LayerParameter::_internal_set_k(float value) {
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.k_ = value;
}
inline void V0LayerParameter::set_k(float value) {
  _internal_set_k(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.k)
}

// optional string source = 16;
inline bool V0LayerParameter::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool V0LayerParameter::has_source() const {
  return _internal_has_source();
}
inline void V0LayerParameter::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& V0LayerParameter::source() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.source)
}
inline std::string* V0LayerParameter::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.source)
  return _s;
}
inline const std::string& V0LayerParameter::_internal_source() const {
  return _impl_.source_.Get();
}
inline void V0LayerParameter::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_source() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void V0LayerParameter::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.source)
}

// optional float scale = 17 [default = 1];
inline bool V0LayerParameter::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_scale() const {
  return _internal_has_scale();
}
inline void V0LayerParameter::clear_scale() {
  _impl_.scale_ = 1;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline float V0LayerParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline float V0LayerParameter::scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.scale)
  return _internal_scale();
}
inline void V0LayerParameter::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.scale_ = value;
}
inline void V0LayerParameter::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.scale)
}

// optional string meanfile = 18;
inline bool V0LayerParameter::_internal_has_meanfile() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool V0LayerParameter::has_meanfile() const {
  return _internal_has_meanfile();
}
inline void V0LayerParameter::clear_meanfile() {
  _impl_.meanfile_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& V0LayerParameter::meanfile() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.meanfile)
  return _internal_meanfile();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_meanfile(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.meanfile_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.meanfile)
}
inline std::string* V0LayerParameter::mutable_meanfile() {
  std::string* _s = _internal_mutable_meanfile();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.meanfile)
  return _s;
}
inline const std::string& V0LayerParameter::_internal_meanfile() const {
  return _impl_.meanfile_.Get();
}
inline void V0LayerParameter::_internal_set_meanfile(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.meanfile_.Set(value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_meanfile() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.meanfile_.Mutable(GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_meanfile() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.meanfile)
  if (!_internal_has_meanfile()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.meanfile_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.meanfile_.IsDefault()) {
    _impl_.meanfile_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void V0LayerParameter::set_allocated_meanfile(std::string* meanfile) {
  if (meanfile != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.meanfile_.SetAllocated(meanfile, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.meanfile_.IsDefault()) {
    _impl_.meanfile_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.meanfile)
}

// optional uint32 batchsize = 19;
inline bool V0LayerParameter::_internal_has_batchsize() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_batchsize() const {
  return _internal_has_batchsize();
}
inline void V0LayerParameter::clear_batchsize() {
  _impl_.batchsize_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t V0LayerParameter::_internal_batchsize() const {
  return _impl_.batchsize_;
}
inline uint32_t V0LayerParameter::batchsize() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.batchsize)
  return _internal_batchsize();
}
inline void V0LayerParameter::_internal_set_batchsize(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.batchsize_ = value;
}
inline void V0LayerParameter::set_batchsize(uint32_t value) {
  _internal_set_batchsize(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.batchsize)
}

// optional uint32 cropsize = 20 [default = 0];
inline bool V0LayerParameter::_internal_has_cropsize() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_cropsize() const {
  return _internal_has_cropsize();
}
inline void V0LayerParameter::clear_cropsize() {
  _impl_.cropsize_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t V0LayerParameter::_internal_cropsize() const {
  return _impl_.cropsize_;
}
inline uint32_t V0LayerParameter::cropsize() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.cropsize)
  return _internal_cropsize();
}
inline void V0LayerParameter::_internal_set_cropsize(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.cropsize_ = value;
}
inline void V0LayerParameter::set_cropsize(uint32_t value) {
  _internal_set_cropsize(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.cropsize)
}

// optional bool mirror = 21 [default = false];
inline bool V0LayerParameter::_internal_has_mirror() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_mirror() const {
  return _internal_has_mirror();
}
inline void V0LayerParameter::clear_mirror() {
  _impl_.mirror_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool V0LayerParameter::_internal_mirror() const {
  return _impl_.mirror_;
}
inline bool V0LayerParameter::mirror() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.mirror)
  return _internal_mirror();
}
inline void V0LayerParameter::_internal_set_mirror(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.mirror_ = value;
}
inline void V0LayerParameter::set_mirror(bool value) {
  _internal_set_mirror(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.mirror)
}

// repeated .opencv_caffe.BlobProto blobs = 50;
inline int V0LayerParameter::_internal_blobs_size() const {
  return _impl_.blobs_.size();
}
inline int V0LayerParameter::blobs_size() const {
  return _internal_blobs_size();
}
inline void V0LayerParameter::clear_blobs() {
  _impl_.blobs_.Clear();
}
inline ::opencv_caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) {
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.blobs)
  return _impl_.blobs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >*
V0LayerParameter::mutable_blobs() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.blobs)
  return &_impl_.blobs_;
}
inline const ::opencv_caffe::BlobProto& V0LayerParameter::_internal_blobs(int index) const {
  return _impl_.blobs_.Get(index);
}
inline const ::opencv_caffe::BlobProto& V0LayerParameter::blobs(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.blobs)
  return _internal_blobs(index);
}
inline ::opencv_caffe::BlobProto* V0LayerParameter::_internal_add_blobs() {
  return _impl_.blobs_.Add();
}
inline ::opencv_caffe::BlobProto* V0LayerParameter::add_blobs() {
  ::opencv_caffe::BlobProto* _add = _internal_add_blobs();
  // @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.blobs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::opencv_caffe::BlobProto >&
V0LayerParameter::blobs() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.blobs)
  return _impl_.blobs_;
}

// repeated float blobs_lr = 51;
inline int V0LayerParameter::_internal_blobs_lr_size() const {
  return _impl_.blobs_lr_.size();
}
inline int V0LayerParameter::blobs_lr_size() const {
  return _internal_blobs_lr_size();
}
inline void V0LayerParameter::clear_blobs_lr() {
  _impl_.blobs_lr_.Clear();
}
inline float V0LayerParameter::_internal_blobs_lr(int index) const {
  return _impl_.blobs_lr_.Get(index);
}
inline float V0LayerParameter::blobs_lr(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.blobs_lr)
  return _internal_blobs_lr(index);
}
inline void V0LayerParameter::set_blobs_lr(int index, float value) {
  _impl_.blobs_lr_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.blobs_lr)
}
inline void V0LayerParameter::_internal_add_blobs_lr(float value) {
  _impl_.blobs_lr_.Add(value);
}
inline void V0LayerParameter::add_blobs_lr(float value) {
  _internal_add_blobs_lr(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.blobs_lr)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::_internal_blobs_lr() const {
  return _impl_.blobs_lr_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::blobs_lr() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.blobs_lr)
  return _internal_blobs_lr();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::_internal_mutable_blobs_lr() {
  return &_impl_.blobs_lr_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::mutable_blobs_lr() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.blobs_lr)
  return _internal_mutable_blobs_lr();
}

// repeated float weight_decay = 52;
inline int V0LayerParameter::_internal_weight_decay_size() const {
  return _impl_.weight_decay_.size();
}
inline int V0LayerParameter::weight_decay_size() const {
  return _internal_weight_decay_size();
}
inline void V0LayerParameter::clear_weight_decay() {
  _impl_.weight_decay_.Clear();
}
inline float V0LayerParameter::_internal_weight_decay(int index) const {
  return _impl_.weight_decay_.Get(index);
}
inline float V0LayerParameter::weight_decay(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.weight_decay)
  return _internal_weight_decay(index);
}
inline void V0LayerParameter::set_weight_decay(int index, float value) {
  _impl_.weight_decay_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.weight_decay)
}
inline void V0LayerParameter::_internal_add_weight_decay(float value) {
  _impl_.weight_decay_.Add(value);
}
inline void V0LayerParameter::add_weight_decay(float value) {
  _internal_add_weight_decay(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.V0LayerParameter.weight_decay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::_internal_weight_decay() const {
  return _impl_.weight_decay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
V0LayerParameter::weight_decay() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.V0LayerParameter.weight_decay)
  return _internal_weight_decay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::_internal_mutable_weight_decay() {
  return &_impl_.weight_decay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
V0LayerParameter::mutable_weight_decay() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.V0LayerParameter.weight_decay)
  return _internal_mutable_weight_decay();
}

// optional uint32 rand_skip = 53 [default = 0];
inline bool V0LayerParameter::_internal_has_rand_skip() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_rand_skip() const {
  return _internal_has_rand_skip();
}
inline void V0LayerParameter::clear_rand_skip() {
  _impl_.rand_skip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t V0LayerParameter::_internal_rand_skip() const {
  return _impl_.rand_skip_;
}
inline uint32_t V0LayerParameter::rand_skip() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.rand_skip)
  return _internal_rand_skip();
}
inline void V0LayerParameter::_internal_set_rand_skip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.rand_skip_ = value;
}
inline void V0LayerParameter::set_rand_skip(uint32_t value) {
  _internal_set_rand_skip(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.rand_skip)
}

// optional float det_fg_threshold = 54 [default = 0.5];
inline bool V0LayerParameter::_internal_has_det_fg_threshold() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool V0LayerParameter::has_det_fg_threshold() const {
  return _internal_has_det_fg_threshold();
}
inline void V0LayerParameter::clear_det_fg_threshold() {
  _impl_.det_fg_threshold_ = 0.5f;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline float V0LayerParameter::_internal_det_fg_threshold() const {
  return _impl_.det_fg_threshold_;
}
inline float V0LayerParameter::det_fg_threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_fg_threshold)
  return _internal_det_fg_threshold();
}
inline void V0LayerParameter::_internal_set_det_fg_threshold(float value) {
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.det_fg_threshold_ = value;
}
inline void V0LayerParameter::set_det_fg_threshold(float value) {
  _internal_set_det_fg_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_fg_threshold)
}

// optional float det_bg_threshold = 55 [default = 0.5];
inline bool V0LayerParameter::_internal_has_det_bg_threshold() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool V0LayerParameter::has_det_bg_threshold() const {
  return _internal_has_det_bg_threshold();
}
inline void V0LayerParameter::clear_det_bg_threshold() {
  _impl_.det_bg_threshold_ = 0.5f;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline float V0LayerParameter::_internal_det_bg_threshold() const {
  return _impl_.det_bg_threshold_;
}
inline float V0LayerParameter::det_bg_threshold() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_bg_threshold)
  return _internal_det_bg_threshold();
}
inline void V0LayerParameter::_internal_set_det_bg_threshold(float value) {
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.det_bg_threshold_ = value;
}
inline void V0LayerParameter::set_det_bg_threshold(float value) {
  _internal_set_det_bg_threshold(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_bg_threshold)
}

// optional float det_fg_fraction = 56 [default = 0.25];
inline bool V0LayerParameter::_internal_has_det_fg_fraction() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool V0LayerParameter::has_det_fg_fraction() const {
  return _internal_has_det_fg_fraction();
}
inline void V0LayerParameter::clear_det_fg_fraction() {
  _impl_.det_fg_fraction_ = 0.25f;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline float V0LayerParameter::_internal_det_fg_fraction() const {
  return _impl_.det_fg_fraction_;
}
inline float V0LayerParameter::det_fg_fraction() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_fg_fraction)
  return _internal_det_fg_fraction();
}
inline void V0LayerParameter::_internal_set_det_fg_fraction(float value) {
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.det_fg_fraction_ = value;
}
inline void V0LayerParameter::set_det_fg_fraction(float value) {
  _internal_set_det_fg_fraction(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_fg_fraction)
}

// optional uint32 det_context_pad = 58 [default = 0];
inline bool V0LayerParameter::_internal_has_det_context_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_det_context_pad() const {
  return _internal_has_det_context_pad();
}
inline void V0LayerParameter::clear_det_context_pad() {
  _impl_.det_context_pad_ = 0u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t V0LayerParameter::_internal_det_context_pad() const {
  return _impl_.det_context_pad_;
}
inline uint32_t V0LayerParameter::det_context_pad() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_context_pad)
  return _internal_det_context_pad();
}
inline void V0LayerParameter::_internal_set_det_context_pad(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.det_context_pad_ = value;
}
inline void V0LayerParameter::set_det_context_pad(uint32_t value) {
  _internal_set_det_context_pad(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_context_pad)
}

// optional string det_crop_mode = 59 [default = "warp"];
inline bool V0LayerParameter::_internal_has_det_crop_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool V0LayerParameter::has_det_crop_mode() const {
  return _internal_has_det_crop_mode();
}
inline void V0LayerParameter::clear_det_crop_mode() {
  _impl_.det_crop_mode_.ClearToDefault(::opencv_caffe::V0LayerParameter::Impl_::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& V0LayerParameter::det_crop_mode() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.det_crop_mode)
  if (_impl_.det_crop_mode_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_det_crop_mode_.get();
  return _internal_det_crop_mode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void V0LayerParameter::set_det_crop_mode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.det_crop_mode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.det_crop_mode)
}
inline std::string* V0LayerParameter::mutable_det_crop_mode() {
  std::string* _s = _internal_mutable_det_crop_mode();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.det_crop_mode)
  return _s;
}
inline const std::string& V0LayerParameter::_internal_det_crop_mode() const {
  return _impl_.det_crop_mode_.Get();
}
inline void V0LayerParameter::_internal_set_det_crop_mode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.det_crop_mode_.Set(value, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::_internal_mutable_det_crop_mode() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.det_crop_mode_.Mutable(::opencv_caffe::V0LayerParameter::Impl_::_i_give_permission_to_break_this_code_default_det_crop_mode_, GetArenaForAllocation());
}
inline std::string* V0LayerParameter::release_det_crop_mode() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.det_crop_mode)
  if (!_internal_has_det_crop_mode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.det_crop_mode_.Release();
  return p;
}
inline void V0LayerParameter::set_allocated_det_crop_mode(std::string* det_crop_mode) {
  if (det_crop_mode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.det_crop_mode_.SetAllocated(det_crop_mode, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.det_crop_mode)
}

// optional int32 new_num = 60 [default = 0];
inline bool V0LayerParameter::_internal_has_new_num() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_new_num() const {
  return _internal_has_new_num();
}
inline void V0LayerParameter::clear_new_num() {
  _impl_.new_num_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline int32_t V0LayerParameter::_internal_new_num() const {
  return _impl_.new_num_;
}
inline int32_t V0LayerParameter::new_num() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_num)
  return _internal_new_num();
}
inline void V0LayerParameter::_internal_set_new_num(int32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.new_num_ = value;
}
inline void V0LayerParameter::set_new_num(int32_t value) {
  _internal_set_new_num(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_num)
}

// optional int32 new_channels = 61 [default = 0];
inline bool V0LayerParameter::_internal_has_new_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_new_channels() const {
  return _internal_has_new_channels();
}
inline void V0LayerParameter::clear_new_channels() {
  _impl_.new_channels_ = 0;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int32_t V0LayerParameter::_internal_new_channels() const {
  return _impl_.new_channels_;
}
inline int32_t V0LayerParameter::new_channels() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_channels)
  return _internal_new_channels();
}
inline void V0LayerParameter::_internal_set_new_channels(int32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.new_channels_ = value;
}
inline void V0LayerParameter::set_new_channels(int32_t value) {
  _internal_set_new_channels(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_channels)
}

// optional int32 new_height = 62 [default = 0];
inline bool V0LayerParameter::_internal_has_new_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_new_height() const {
  return _internal_has_new_height();
}
inline void V0LayerParameter::clear_new_height() {
  _impl_.new_height_ = 0;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int32_t V0LayerParameter::_internal_new_height() const {
  return _impl_.new_height_;
}
inline int32_t V0LayerParameter::new_height() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_height)
  return _internal_new_height();
}
inline void V0LayerParameter::_internal_set_new_height(int32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.new_height_ = value;
}
inline void V0LayerParameter::set_new_height(int32_t value) {
  _internal_set_new_height(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_height)
}

// optional int32 new_width = 63 [default = 0];
inline bool V0LayerParameter::_internal_has_new_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_new_width() const {
  return _internal_has_new_width();
}
inline void V0LayerParameter::clear_new_width() {
  _impl_.new_width_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline int32_t V0LayerParameter::_internal_new_width() const {
  return _impl_.new_width_;
}
inline int32_t V0LayerParameter::new_width() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.new_width)
  return _internal_new_width();
}
inline void V0LayerParameter::_internal_set_new_width(int32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.new_width_ = value;
}
inline void V0LayerParameter::set_new_width(int32_t value) {
  _internal_set_new_width(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.new_width)
}

// optional bool shuffle_images = 64 [default = false];
inline bool V0LayerParameter::_internal_has_shuffle_images() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_shuffle_images() const {
  return _internal_has_shuffle_images();
}
inline void V0LayerParameter::clear_shuffle_images() {
  _impl_.shuffle_images_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool V0LayerParameter::_internal_shuffle_images() const {
  return _impl_.shuffle_images_;
}
inline bool V0LayerParameter::shuffle_images() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.shuffle_images)
  return _internal_shuffle_images();
}
inline void V0LayerParameter::_internal_set_shuffle_images(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.shuffle_images_ = value;
}
inline void V0LayerParameter::set_shuffle_images(bool value) {
  _internal_set_shuffle_images(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.shuffle_images)
}

// optional uint32 concat_dim = 65 [default = 1];
inline bool V0LayerParameter::_internal_has_concat_dim() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool V0LayerParameter::has_concat_dim() const {
  return _internal_has_concat_dim();
}
inline void V0LayerParameter::clear_concat_dim() {
  _impl_.concat_dim_ = 1u;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline uint32_t V0LayerParameter::_internal_concat_dim() const {
  return _impl_.concat_dim_;
}
inline uint32_t V0LayerParameter::concat_dim() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.concat_dim)
  return _internal_concat_dim();
}
inline void V0LayerParameter::_internal_set_concat_dim(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.concat_dim_ = value;
}
inline void V0LayerParameter::set_concat_dim(uint32_t value) {
  _internal_set_concat_dim(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.V0LayerParameter.concat_dim)
}

// optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
inline bool V0LayerParameter::_internal_has_hdf5_output_param() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hdf5_output_param_ != nullptr);
  return value;
}
inline bool V0LayerParameter::has_hdf5_output_param() const {
  return _internal_has_hdf5_output_param();
}
inline void V0LayerParameter::clear_hdf5_output_param() {
  if (_impl_.hdf5_output_param_ != nullptr) _impl_.hdf5_output_param_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::opencv_caffe::HDF5OutputParameter& V0LayerParameter::_internal_hdf5_output_param() const {
  const ::opencv_caffe::HDF5OutputParameter* p = _impl_.hdf5_output_param_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::HDF5OutputParameter&>(
      ::opencv_caffe::_HDF5OutputParameter_default_instance_);
}
inline const ::opencv_caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.V0LayerParameter.hdf5_output_param)
  return _internal_hdf5_output_param();
}
inline void V0LayerParameter::unsafe_arena_set_allocated_hdf5_output_param(
    ::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hdf5_output_param_);
  }
  _impl_.hdf5_output_param_ = hdf5_output_param;
  if (hdf5_output_param) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.V0LayerParameter.hdf5_output_param)
}
inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::HDF5OutputParameter* temp = _impl_.hdf5_output_param_;
  _impl_.hdf5_output_param_ = 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 ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::unsafe_arena_release_hdf5_output_param() {
  // @@protoc_insertion_point(field_release:opencv_caffe.V0LayerParameter.hdf5_output_param)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::opencv_caffe::HDF5OutputParameter* temp = _impl_.hdf5_output_param_;
  _impl_.hdf5_output_param_ = nullptr;
  return temp;
}
inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::_internal_mutable_hdf5_output_param() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.hdf5_output_param_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::HDF5OutputParameter>(GetArenaForAllocation());
    _impl_.hdf5_output_param_ = p;
  }
  return _impl_.hdf5_output_param_;
}
inline ::opencv_caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() {
  ::opencv_caffe::HDF5OutputParameter* _msg = _internal_mutable_hdf5_output_param();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.V0LayerParameter.hdf5_output_param)
  return _msg;
}
inline void V0LayerParameter::set_allocated_hdf5_output_param(::opencv_caffe::HDF5OutputParameter* hdf5_output_param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hdf5_output_param_;
  }
  if (hdf5_output_param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hdf5_output_param);
    if (message_arena != submessage_arena) {
      hdf5_output_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hdf5_output_param, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.hdf5_output_param_ = hdf5_output_param;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.V0LayerParameter.hdf5_output_param)
}

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

// PReLUParameter

// optional .opencv_caffe.FillerParameter filler = 1;
inline bool PReLUParameter::_internal_has_filler() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.filler_ != nullptr);
  return value;
}
inline bool PReLUParameter::has_filler() const {
  return _internal_has_filler();
}
inline void PReLUParameter::clear_filler() {
  if (_impl_.filler_ != nullptr) _impl_.filler_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::opencv_caffe::FillerParameter& PReLUParameter::_internal_filler() const {
  const ::opencv_caffe::FillerParameter* p = _impl_.filler_;
  return p != nullptr ? *p : reinterpret_cast<const ::opencv_caffe::FillerParameter&>(
      ::opencv_caffe::_FillerParameter_default_instance_);
}
inline const ::opencv_caffe::FillerParameter& PReLUParameter::filler() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PReLUParameter.filler)
  return _internal_filler();
}
inline void PReLUParameter::unsafe_arena_set_allocated_filler(
    ::opencv_caffe::FillerParameter* filler) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.filler_);
  }
  _impl_.filler_ = filler;
  if (filler) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:opencv_caffe.PReLUParameter.filler)
}
inline ::opencv_caffe::FillerParameter* PReLUParameter::release_filler() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.filler_;
  _impl_.filler_ = 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 ::opencv_caffe::FillerParameter* PReLUParameter::unsafe_arena_release_filler() {
  // @@protoc_insertion_point(field_release:opencv_caffe.PReLUParameter.filler)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::opencv_caffe::FillerParameter* temp = _impl_.filler_;
  _impl_.filler_ = nullptr;
  return temp;
}
inline ::opencv_caffe::FillerParameter* PReLUParameter::_internal_mutable_filler() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.filler_ == nullptr) {
    auto* p = CreateMaybeMessage<::opencv_caffe::FillerParameter>(GetArenaForAllocation());
    _impl_.filler_ = p;
  }
  return _impl_.filler_;
}
inline ::opencv_caffe::FillerParameter* PReLUParameter::mutable_filler() {
  ::opencv_caffe::FillerParameter* _msg = _internal_mutable_filler();
  // @@protoc_insertion_point(field_mutable:opencv_caffe.PReLUParameter.filler)
  return _msg;
}
inline void PReLUParameter::set_allocated_filler(::opencv_caffe::FillerParameter* filler) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.filler_;
  }
  if (filler) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(filler);
    if (message_arena != submessage_arena) {
      filler = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, filler, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filler_ = filler;
  // @@protoc_insertion_point(field_set_allocated:opencv_caffe.PReLUParameter.filler)
}

// optional bool channel_shared = 2 [default = false];
inline bool PReLUParameter::_internal_has_channel_shared() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PReLUParameter::has_channel_shared() const {
  return _internal_has_channel_shared();
}
inline void PReLUParameter::clear_channel_shared() {
  _impl_.channel_shared_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool PReLUParameter::_internal_channel_shared() const {
  return _impl_.channel_shared_;
}
inline bool PReLUParameter::channel_shared() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PReLUParameter.channel_shared)
  return _internal_channel_shared();
}
inline void PReLUParameter::_internal_set_channel_shared(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.channel_shared_ = value;
}
inline void PReLUParameter::set_channel_shared(bool value) {
  _internal_set_channel_shared(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PReLUParameter.channel_shared)
}

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

// NormalizedBBox

// optional float xmin = 1;
inline bool NormalizedBBox::_internal_has_xmin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NormalizedBBox::has_xmin() const {
  return _internal_has_xmin();
}
inline void NormalizedBBox::clear_xmin() {
  _impl_.xmin_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float NormalizedBBox::_internal_xmin() const {
  return _impl_.xmin_;
}
inline float NormalizedBBox::xmin() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.xmin)
  return _internal_xmin();
}
inline void NormalizedBBox::_internal_set_xmin(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.xmin_ = value;
}
inline void NormalizedBBox::set_xmin(float value) {
  _internal_set_xmin(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.xmin)
}

// optional float ymin = 2;
inline bool NormalizedBBox::_internal_has_ymin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NormalizedBBox::has_ymin() const {
  return _internal_has_ymin();
}
inline void NormalizedBBox::clear_ymin() {
  _impl_.ymin_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float NormalizedBBox::_internal_ymin() const {
  return _impl_.ymin_;
}
inline float NormalizedBBox::ymin() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.ymin)
  return _internal_ymin();
}
inline void NormalizedBBox::_internal_set_ymin(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.ymin_ = value;
}
inline void NormalizedBBox::set_ymin(float value) {
  _internal_set_ymin(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.ymin)
}

// optional float xmax = 3;
inline bool NormalizedBBox::_internal_has_xmax() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NormalizedBBox::has_xmax() const {
  return _internal_has_xmax();
}
inline void NormalizedBBox::clear_xmax() {
  _impl_.xmax_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float NormalizedBBox::_internal_xmax() const {
  return _impl_.xmax_;
}
inline float NormalizedBBox::xmax() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.xmax)
  return _internal_xmax();
}
inline void NormalizedBBox::_internal_set_xmax(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.xmax_ = value;
}
inline void NormalizedBBox::set_xmax(float value) {
  _internal_set_xmax(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.xmax)
}

// optional float ymax = 4;
inline bool NormalizedBBox::_internal_has_ymax() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NormalizedBBox::has_ymax() const {
  return _internal_has_ymax();
}
inline void NormalizedBBox::clear_ymax() {
  _impl_.ymax_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float NormalizedBBox::_internal_ymax() const {
  return _impl_.ymax_;
}
inline float NormalizedBBox::ymax() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.ymax)
  return _internal_ymax();
}
inline void NormalizedBBox::_internal_set_ymax(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ymax_ = value;
}
inline void NormalizedBBox::set_ymax(float value) {
  _internal_set_ymax(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.ymax)
}

// optional int32 label = 5;
inline bool NormalizedBBox::_internal_has_label() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool NormalizedBBox::has_label() const {
  return _internal_has_label();
}
inline void NormalizedBBox::clear_label() {
  _impl_.label_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t NormalizedBBox::_internal_label() const {
  return _impl_.label_;
}
inline int32_t NormalizedBBox::label() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.label)
  return _internal_label();
}
inline void NormalizedBBox::_internal_set_label(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.label_ = value;
}
inline void NormalizedBBox::set_label(int32_t value) {
  _internal_set_label(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.label)
}

// optional bool difficult = 6;
inline bool NormalizedBBox::_internal_has_difficult() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool NormalizedBBox::has_difficult() const {
  return _internal_has_difficult();
}
inline void NormalizedBBox::clear_difficult() {
  _impl_.difficult_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool NormalizedBBox::_internal_difficult() const {
  return _impl_.difficult_;
}
inline bool NormalizedBBox::difficult() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.difficult)
  return _internal_difficult();
}
inline void NormalizedBBox::_internal_set_difficult(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.difficult_ = value;
}
inline void NormalizedBBox::set_difficult(bool value) {
  _internal_set_difficult(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.difficult)
}

// optional float score = 7;
inline bool NormalizedBBox::_internal_has_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool NormalizedBBox::has_score() const {
  return _internal_has_score();
}
inline void NormalizedBBox::clear_score() {
  _impl_.score_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float NormalizedBBox::_internal_score() const {
  return _impl_.score_;
}
inline float NormalizedBBox::score() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.score)
  return _internal_score();
}
inline void NormalizedBBox::_internal_set_score(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.score_ = value;
}
inline void NormalizedBBox::set_score(float value) {
  _internal_set_score(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.score)
}

// optional float size = 8;
inline bool NormalizedBBox::_internal_has_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool NormalizedBBox::has_size() const {
  return _internal_has_size();
}
inline void NormalizedBBox::clear_size() {
  _impl_.size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float NormalizedBBox::_internal_size() const {
  return _impl_.size_;
}
inline float NormalizedBBox::size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.NormalizedBBox.size)
  return _internal_size();
}
inline void NormalizedBBox::_internal_set_size(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.size_ = value;
}
inline void NormalizedBBox::set_size(float value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.NormalizedBBox.size)
}

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

// ROIPoolingParameter

// optional uint32 pooled_h = 1 [default = 0];
inline bool ROIPoolingParameter::_internal_has_pooled_h() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ROIPoolingParameter::has_pooled_h() const {
  return _internal_has_pooled_h();
}
inline void ROIPoolingParameter::clear_pooled_h() {
  _impl_.pooled_h_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ROIPoolingParameter::_internal_pooled_h() const {
  return _impl_.pooled_h_;
}
inline uint32_t ROIPoolingParameter::pooled_h() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.pooled_h)
  return _internal_pooled_h();
}
inline void ROIPoolingParameter::_internal_set_pooled_h(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pooled_h_ = value;
}
inline void ROIPoolingParameter::set_pooled_h(uint32_t value) {
  _internal_set_pooled_h(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.pooled_h)
}

// optional uint32 pooled_w = 2 [default = 0];
inline bool ROIPoolingParameter::_internal_has_pooled_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ROIPoolingParameter::has_pooled_w() const {
  return _internal_has_pooled_w();
}
inline void ROIPoolingParameter::clear_pooled_w() {
  _impl_.pooled_w_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ROIPoolingParameter::_internal_pooled_w() const {
  return _impl_.pooled_w_;
}
inline uint32_t ROIPoolingParameter::pooled_w() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.pooled_w)
  return _internal_pooled_w();
}
inline void ROIPoolingParameter::_internal_set_pooled_w(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pooled_w_ = value;
}
inline void ROIPoolingParameter::set_pooled_w(uint32_t value) {
  _internal_set_pooled_w(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.pooled_w)
}

// optional float spatial_scale = 3 [default = 1];
inline bool ROIPoolingParameter::_internal_has_spatial_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ROIPoolingParameter::has_spatial_scale() const {
  return _internal_has_spatial_scale();
}
inline void ROIPoolingParameter::clear_spatial_scale() {
  _impl_.spatial_scale_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float ROIPoolingParameter::_internal_spatial_scale() const {
  return _impl_.spatial_scale_;
}
inline float ROIPoolingParameter::spatial_scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ROIPoolingParameter.spatial_scale)
  return _internal_spatial_scale();
}
inline void ROIPoolingParameter::_internal_set_spatial_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.spatial_scale_ = value;
}
inline void ROIPoolingParameter::set_spatial_scale(float value) {
  _internal_set_spatial_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ROIPoolingParameter.spatial_scale)
}

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

// ProposalParameter

// optional uint32 feat_stride = 1 [default = 16];
inline bool ProposalParameter::_internal_has_feat_stride() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ProposalParameter::has_feat_stride() const {
  return _internal_has_feat_stride();
}
inline void ProposalParameter::clear_feat_stride() {
  _impl_.feat_stride_ = 16u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ProposalParameter::_internal_feat_stride() const {
  return _impl_.feat_stride_;
}
inline uint32_t ProposalParameter::feat_stride() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.feat_stride)
  return _internal_feat_stride();
}
inline void ProposalParameter::_internal_set_feat_stride(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.feat_stride_ = value;
}
inline void ProposalParameter::set_feat_stride(uint32_t value) {
  _internal_set_feat_stride(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.feat_stride)
}

// optional uint32 base_size = 2 [default = 16];
inline bool ProposalParameter::_internal_has_base_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProposalParameter::has_base_size() const {
  return _internal_has_base_size();
}
inline void ProposalParameter::clear_base_size() {
  _impl_.base_size_ = 16u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ProposalParameter::_internal_base_size() const {
  return _impl_.base_size_;
}
inline uint32_t ProposalParameter::base_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.base_size)
  return _internal_base_size();
}
inline void ProposalParameter::_internal_set_base_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.base_size_ = value;
}
inline void ProposalParameter::set_base_size(uint32_t value) {
  _internal_set_base_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.base_size)
}

// optional uint32 min_size = 3 [default = 16];
inline bool ProposalParameter::_internal_has_min_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ProposalParameter::has_min_size() const {
  return _internal_has_min_size();
}
inline void ProposalParameter::clear_min_size() {
  _impl_.min_size_ = 16u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ProposalParameter::_internal_min_size() const {
  return _impl_.min_size_;
}
inline uint32_t ProposalParameter::min_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.min_size)
  return _internal_min_size();
}
inline void ProposalParameter::_internal_set_min_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.min_size_ = value;
}
inline void ProposalParameter::set_min_size(uint32_t value) {
  _internal_set_min_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.min_size)
}

// repeated float ratio = 4;
inline int ProposalParameter::_internal_ratio_size() const {
  return _impl_.ratio_.size();
}
inline int ProposalParameter::ratio_size() const {
  return _internal_ratio_size();
}
inline void ProposalParameter::clear_ratio() {
  _impl_.ratio_.Clear();
}
inline float ProposalParameter::_internal_ratio(int index) const {
  return _impl_.ratio_.Get(index);
}
inline float ProposalParameter::ratio(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.ratio)
  return _internal_ratio(index);
}
inline void ProposalParameter::set_ratio(int index, float value) {
  _impl_.ratio_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.ratio)
}
inline void ProposalParameter::_internal_add_ratio(float value) {
  _impl_.ratio_.Add(value);
}
inline void ProposalParameter::add_ratio(float value) {
  _internal_add_ratio(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.ProposalParameter.ratio)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
ProposalParameter::_internal_ratio() const {
  return _impl_.ratio_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
ProposalParameter::ratio() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.ProposalParameter.ratio)
  return _internal_ratio();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
ProposalParameter::_internal_mutable_ratio() {
  return &_impl_.ratio_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
ProposalParameter::mutable_ratio() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ProposalParameter.ratio)
  return _internal_mutable_ratio();
}

// repeated float scale = 5;
inline int ProposalParameter::_internal_scale_size() const {
  return _impl_.scale_.size();
}
inline int ProposalParameter::scale_size() const {
  return _internal_scale_size();
}
inline void ProposalParameter::clear_scale() {
  _impl_.scale_.Clear();
}
inline float ProposalParameter::_internal_scale(int index) const {
  return _impl_.scale_.Get(index);
}
inline float ProposalParameter::scale(int index) const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.scale)
  return _internal_scale(index);
}
inline void ProposalParameter::set_scale(int index, float value) {
  _impl_.scale_.Set(index, value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.scale)
}
inline void ProposalParameter::_internal_add_scale(float value) {
  _impl_.scale_.Add(value);
}
inline void ProposalParameter::add_scale(float value) {
  _internal_add_scale(value);
  // @@protoc_insertion_point(field_add:opencv_caffe.ProposalParameter.scale)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
ProposalParameter::_internal_scale() const {
  return _impl_.scale_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
ProposalParameter::scale() const {
  // @@protoc_insertion_point(field_list:opencv_caffe.ProposalParameter.scale)
  return _internal_scale();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
ProposalParameter::_internal_mutable_scale() {
  return &_impl_.scale_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
ProposalParameter::mutable_scale() {
  // @@protoc_insertion_point(field_mutable_list:opencv_caffe.ProposalParameter.scale)
  return _internal_mutable_scale();
}

// optional uint32 pre_nms_topn = 6 [default = 6000];
inline bool ProposalParameter::_internal_has_pre_nms_topn() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ProposalParameter::has_pre_nms_topn() const {
  return _internal_has_pre_nms_topn();
}
inline void ProposalParameter::clear_pre_nms_topn() {
  _impl_.pre_nms_topn_ = 6000u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ProposalParameter::_internal_pre_nms_topn() const {
  return _impl_.pre_nms_topn_;
}
inline uint32_t ProposalParameter::pre_nms_topn() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.pre_nms_topn)
  return _internal_pre_nms_topn();
}
inline void ProposalParameter::_internal_set_pre_nms_topn(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.pre_nms_topn_ = value;
}
inline void ProposalParameter::set_pre_nms_topn(uint32_t value) {
  _internal_set_pre_nms_topn(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.pre_nms_topn)
}

// optional uint32 post_nms_topn = 7 [default = 300];
inline bool ProposalParameter::_internal_has_post_nms_topn() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ProposalParameter::has_post_nms_topn() const {
  return _internal_has_post_nms_topn();
}
inline void ProposalParameter::clear_post_nms_topn() {
  _impl_.post_nms_topn_ = 300u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ProposalParameter::_internal_post_nms_topn() const {
  return _impl_.post_nms_topn_;
}
inline uint32_t ProposalParameter::post_nms_topn() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.post_nms_topn)
  return _internal_post_nms_topn();
}
inline void ProposalParameter::_internal_set_post_nms_topn(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.post_nms_topn_ = value;
}
inline void ProposalParameter::set_post_nms_topn(uint32_t value) {
  _internal_set_post_nms_topn(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.post_nms_topn)
}

// optional float nms_thresh = 8 [default = 0.7];
inline bool ProposalParameter::_internal_has_nms_thresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ProposalParameter::has_nms_thresh() const {
  return _internal_has_nms_thresh();
}
inline void ProposalParameter::clear_nms_thresh() {
  _impl_.nms_thresh_ = 0.7f;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float ProposalParameter::_internal_nms_thresh() const {
  return _impl_.nms_thresh_;
}
inline float ProposalParameter::nms_thresh() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.ProposalParameter.nms_thresh)
  return _internal_nms_thresh();
}
inline void ProposalParameter::_internal_set_nms_thresh(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.nms_thresh_ = value;
}
inline void ProposalParameter::set_nms_thresh(float value) {
  _internal_set_nms_thresh(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.ProposalParameter.nms_thresh)
}

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

// PSROIPoolingParameter

// required float spatial_scale = 1;
inline bool PSROIPoolingParameter::_internal_has_spatial_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PSROIPoolingParameter::has_spatial_scale() const {
  return _internal_has_spatial_scale();
}
inline void PSROIPoolingParameter::clear_spatial_scale() {
  _impl_.spatial_scale_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float PSROIPoolingParameter::_internal_spatial_scale() const {
  return _impl_.spatial_scale_;
}
inline float PSROIPoolingParameter::spatial_scale() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.spatial_scale)
  return _internal_spatial_scale();
}
inline void PSROIPoolingParameter::_internal_set_spatial_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.spatial_scale_ = value;
}
inline void PSROIPoolingParameter::set_spatial_scale(float value) {
  _internal_set_spatial_scale(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.spatial_scale)
}

// required int32 output_dim = 2;
inline bool PSROIPoolingParameter::_internal_has_output_dim() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PSROIPoolingParameter::has_output_dim() const {
  return _internal_has_output_dim();
}
inline void PSROIPoolingParameter::clear_output_dim() {
  _impl_.output_dim_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t PSROIPoolingParameter::_internal_output_dim() const {
  return _impl_.output_dim_;
}
inline int32_t PSROIPoolingParameter::output_dim() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.output_dim)
  return _internal_output_dim();
}
inline void PSROIPoolingParameter::_internal_set_output_dim(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.output_dim_ = value;
}
inline void PSROIPoolingParameter::set_output_dim(int32_t value) {
  _internal_set_output_dim(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.output_dim)
}

// required int32 group_size = 3;
inline bool PSROIPoolingParameter::_internal_has_group_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PSROIPoolingParameter::has_group_size() const {
  return _internal_has_group_size();
}
inline void PSROIPoolingParameter::clear_group_size() {
  _impl_.group_size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t PSROIPoolingParameter::_internal_group_size() const {
  return _impl_.group_size_;
}
inline int32_t PSROIPoolingParameter::group_size() const {
  // @@protoc_insertion_point(field_get:opencv_caffe.PSROIPoolingParameter.group_size)
  return _internal_group_size();
}
inline void PSROIPoolingParameter::_internal_set_group_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.group_size_ = value;
}
inline void PSROIPoolingParameter::set_group_size(int32_t value) {
  _internal_set_group_size(value);
  // @@protoc_insertion_point(field_set:opencv_caffe.PSROIPoolingParameter.group_size)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace opencv_caffe

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::opencv_caffe::PriorBoxParameter_CodeType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::PriorBoxParameter_CodeType>() {
  return ::opencv_caffe::PriorBoxParameter_CodeType_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::FillerParameter_VarianceNorm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::FillerParameter_VarianceNorm>() {
  return ::opencv_caffe::FillerParameter_VarianceNorm_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SolverParameter_SnapshotFormat> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SolverParameter_SnapshotFormat>() {
  return ::opencv_caffe::SolverParameter_SnapshotFormat_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SolverParameter_SolverMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SolverParameter_SolverMode>() {
  return ::opencv_caffe::SolverParameter_SolverMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SolverParameter_SolverType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SolverParameter_SolverType>() {
  return ::opencv_caffe::SolverParameter_SolverType_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ParamSpec_DimCheckMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ParamSpec_DimCheckMode>() {
  return ::opencv_caffe::ParamSpec_DimCheckMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::LossParameter_NormalizationMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::LossParameter_NormalizationMode>() {
  return ::opencv_caffe::LossParameter_NormalizationMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ConvolutionParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ConvolutionParameter_Engine>() {
  return ::opencv_caffe::ConvolutionParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::DataParameter_DB> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::DataParameter_DB>() {
  return ::opencv_caffe::DataParameter_DB_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::EltwiseParameter_EltwiseOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::EltwiseParameter_EltwiseOp>() {
  return ::opencv_caffe::EltwiseParameter_EltwiseOp_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::HingeLossParameter_Norm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::HingeLossParameter_Norm>() {
  return ::opencv_caffe::HingeLossParameter_Norm_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::LRNParameter_NormRegion> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::LRNParameter_NormRegion>() {
  return ::opencv_caffe::LRNParameter_NormRegion_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::LRNParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::LRNParameter_Engine>() {
  return ::opencv_caffe::LRNParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::PoolingParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::PoolingParameter_PoolMethod>() {
  return ::opencv_caffe::PoolingParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::PoolingParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::PoolingParameter_Engine>() {
  return ::opencv_caffe::PoolingParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ReductionParameter_ReductionOp> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ReductionParameter_ReductionOp>() {
  return ::opencv_caffe::ReductionParameter_ReductionOp_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::ReLUParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::ReLUParameter_Engine>() {
  return ::opencv_caffe::ReLUParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SigmoidParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SigmoidParameter_Engine>() {
  return ::opencv_caffe::SigmoidParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SoftmaxParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SoftmaxParameter_Engine>() {
  return ::opencv_caffe::SoftmaxParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::TanHParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::TanHParameter_Engine>() {
  return ::opencv_caffe::TanHParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SPPParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SPPParameter_PoolMethod>() {
  return ::opencv_caffe::SPPParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::SPPParameter_Engine> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::SPPParameter_Engine>() {
  return ::opencv_caffe::SPPParameter_Engine_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::V1LayerParameter_LayerType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::V1LayerParameter_LayerType>() {
  return ::opencv_caffe::V1LayerParameter_LayerType_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::V1LayerParameter_DimCheckMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::V1LayerParameter_DimCheckMode>() {
  return ::opencv_caffe::V1LayerParameter_DimCheckMode_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::V0LayerParameter_PoolMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::V0LayerParameter_PoolMethod>() {
  return ::opencv_caffe::V0LayerParameter_PoolMethod_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::Type>() {
  return ::opencv_caffe::Type_descriptor();
}
template <> struct is_proto_enum< ::opencv_caffe::Phase> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_caffe::Phase>() {
  return ::opencv_caffe::Phase_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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