opencv/modules/dnn/misc/caffe/opencv-caffe.pb.cc

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

#include "opencv-caffe.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// This is a temporary google only hack
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
#include "third_party/protobuf/version.h"
#endif
// @@protoc_insertion_point(includes)
namespace opencv_caffe {
class BlobShapeDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<BlobShape>
      _instance;
} _BlobShape_default_instance_;
class BlobProtoDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<BlobProto>
      _instance;
} _BlobProto_default_instance_;
class BlobProtoVectorDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<BlobProtoVector>
      _instance;
} _BlobProtoVector_default_instance_;
class PermuteParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PermuteParameter>
      _instance;
} _PermuteParameter_default_instance_;
class NormalizeBBoxParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<NormalizeBBoxParameter>
      _instance;
} _NormalizeBBoxParameter_default_instance_;
class PriorBoxParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PriorBoxParameter>
      _instance;
} _PriorBoxParameter_default_instance_;
class DetectionOutputParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DetectionOutputParameter>
      _instance;
} _DetectionOutputParameter_default_instance_;
class DatumDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<Datum>
      _instance;
} _Datum_default_instance_;
class FillerParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<FillerParameter>
      _instance;
} _FillerParameter_default_instance_;
class NetParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<NetParameter>
      _instance;
} _NetParameter_default_instance_;
class SolverParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SolverParameter>
      _instance;
} _SolverParameter_default_instance_;
class SolverStateDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SolverState>
      _instance;
} _SolverState_default_instance_;
class NetStateDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<NetState>
      _instance;
} _NetState_default_instance_;
class NetStateRuleDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<NetStateRule>
      _instance;
} _NetStateRule_default_instance_;
class ParamSpecDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ParamSpec>
      _instance;
} _ParamSpec_default_instance_;
class LayerParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<LayerParameter>
      _instance;
} _LayerParameter_default_instance_;
class TransformationParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TransformationParameter>
      _instance;
} _TransformationParameter_default_instance_;
class LossParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<LossParameter>
      _instance;
} _LossParameter_default_instance_;
class AccuracyParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<AccuracyParameter>
      _instance;
} _AccuracyParameter_default_instance_;
class ArgMaxParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ArgMaxParameter>
      _instance;
} _ArgMaxParameter_default_instance_;
class ConcatParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ConcatParameter>
      _instance;
} _ConcatParameter_default_instance_;
class BatchNormParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<BatchNormParameter>
      _instance;
} _BatchNormParameter_default_instance_;
class BiasParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<BiasParameter>
      _instance;
} _BiasParameter_default_instance_;
class ContrastiveLossParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ContrastiveLossParameter>
      _instance;
} _ContrastiveLossParameter_default_instance_;
class ConvolutionParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ConvolutionParameter>
      _instance;
} _ConvolutionParameter_default_instance_;
class CropParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<CropParameter>
      _instance;
} _CropParameter_default_instance_;
class DataParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DataParameter>
      _instance;
} _DataParameter_default_instance_;
class NonMaximumSuppressionParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<NonMaximumSuppressionParameter>
      _instance;
} _NonMaximumSuppressionParameter_default_instance_;
class SaveOutputParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SaveOutputParameter>
      _instance;
} _SaveOutputParameter_default_instance_;
class DropoutParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DropoutParameter>
      _instance;
} _DropoutParameter_default_instance_;
class DummyDataParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DummyDataParameter>
      _instance;
} _DummyDataParameter_default_instance_;
class EltwiseParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<EltwiseParameter>
      _instance;
} _EltwiseParameter_default_instance_;
class ELUParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ELUParameter>
      _instance;
} _ELUParameter_default_instance_;
class EmbedParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<EmbedParameter>
      _instance;
} _EmbedParameter_default_instance_;
class ExpParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ExpParameter>
      _instance;
} _ExpParameter_default_instance_;
class FlattenParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<FlattenParameter>
      _instance;
} _FlattenParameter_default_instance_;
class HDF5DataParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<HDF5DataParameter>
      _instance;
} _HDF5DataParameter_default_instance_;
class HDF5OutputParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<HDF5OutputParameter>
      _instance;
} _HDF5OutputParameter_default_instance_;
class HingeLossParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<HingeLossParameter>
      _instance;
} _HingeLossParameter_default_instance_;
class ImageDataParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ImageDataParameter>
      _instance;
} _ImageDataParameter_default_instance_;
class InfogainLossParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<InfogainLossParameter>
      _instance;
} _InfogainLossParameter_default_instance_;
class InnerProductParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<InnerProductParameter>
      _instance;
} _InnerProductParameter_default_instance_;
class InputParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<InputParameter>
      _instance;
} _InputParameter_default_instance_;
class LogParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<LogParameter>
      _instance;
} _LogParameter_default_instance_;
class LRNParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<LRNParameter>
      _instance;
} _LRNParameter_default_instance_;
class MemoryDataParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<MemoryDataParameter>
      _instance;
} _MemoryDataParameter_default_instance_;
class MVNParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<MVNParameter>
      _instance;
} _MVNParameter_default_instance_;
class ParameterParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ParameterParameter>
      _instance;
} _ParameterParameter_default_instance_;
class PoolingParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PoolingParameter>
      _instance;
} _PoolingParameter_default_instance_;
class PowerParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PowerParameter>
      _instance;
} _PowerParameter_default_instance_;
class PythonParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PythonParameter>
      _instance;
} _PythonParameter_default_instance_;
class RecurrentParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RecurrentParameter>
      _instance;
} _RecurrentParameter_default_instance_;
class ReductionParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ReductionParameter>
      _instance;
} _ReductionParameter_default_instance_;
class ReLUParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ReLUParameter>
      _instance;
} _ReLUParameter_default_instance_;
class ReshapeParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ReshapeParameter>
      _instance;
} _ReshapeParameter_default_instance_;
class ScaleParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ScaleParameter>
      _instance;
} _ScaleParameter_default_instance_;
class SigmoidParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SigmoidParameter>
      _instance;
} _SigmoidParameter_default_instance_;
class SliceParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SliceParameter>
      _instance;
} _SliceParameter_default_instance_;
class SoftmaxParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SoftmaxParameter>
      _instance;
} _SoftmaxParameter_default_instance_;
class TanHParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TanHParameter>
      _instance;
} _TanHParameter_default_instance_;
class TileParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TileParameter>
      _instance;
} _TileParameter_default_instance_;
class ThresholdParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ThresholdParameter>
      _instance;
} _ThresholdParameter_default_instance_;
class WindowDataParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<WindowDataParameter>
      _instance;
} _WindowDataParameter_default_instance_;
class SPPParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SPPParameter>
      _instance;
} _SPPParameter_default_instance_;
class V1LayerParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<V1LayerParameter>
      _instance;
} _V1LayerParameter_default_instance_;
class V0LayerParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<V0LayerParameter>
      _instance;
} _V0LayerParameter_default_instance_;
class PReLUParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PReLUParameter>
      _instance;
} _PReLUParameter_default_instance_;
class NormalizedBBoxDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<NormalizedBBox>
      _instance;
} _NormalizedBBox_default_instance_;
class ROIPoolingParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ROIPoolingParameter>
      _instance;
} _ROIPoolingParameter_default_instance_;
class ProposalParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<ProposalParameter>
      _instance;
} _ProposalParameter_default_instance_;
class PSROIPoolingParameterDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<PSROIPoolingParameter>
      _instance;
} _PSROIPoolingParameter_default_instance_;
}  // namespace opencv_caffe
namespace protobuf_opencv_2dcaffe_2eproto {
void InitDefaultsBlobShapeImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_BlobShape_default_instance_;
    new (ptr) ::opencv_caffe::BlobShape();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::BlobShape::InitAsDefaultInstance();
}

void InitDefaultsBlobShape() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsBlobShapeImpl);
}

void InitDefaultsBlobProtoImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  {
    void* ptr = &::opencv_caffe::_BlobProto_default_instance_;
    new (ptr) ::opencv_caffe::BlobProto();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::BlobProto::InitAsDefaultInstance();
}

void InitDefaultsBlobProto() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsBlobProtoImpl);
}

void InitDefaultsBlobProtoVectorImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  {
    void* ptr = &::opencv_caffe::_BlobProtoVector_default_instance_;
    new (ptr) ::opencv_caffe::BlobProtoVector();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::BlobProtoVector::InitAsDefaultInstance();
}

void InitDefaultsBlobProtoVector() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsBlobProtoVectorImpl);
}

void InitDefaultsPermuteParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_PermuteParameter_default_instance_;
    new (ptr) ::opencv_caffe::PermuteParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PermuteParameter::InitAsDefaultInstance();
}

void InitDefaultsPermuteParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPermuteParameterImpl);
}

void InitDefaultsNormalizeBBoxParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_NormalizeBBoxParameter_default_instance_;
    new (ptr) ::opencv_caffe::NormalizeBBoxParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::NormalizeBBoxParameter::InitAsDefaultInstance();
}

void InitDefaultsNormalizeBBoxParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsNormalizeBBoxParameterImpl);
}

void InitDefaultsPriorBoxParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_PriorBoxParameter_default_instance_;
    new (ptr) ::opencv_caffe::PriorBoxParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PriorBoxParameter::InitAsDefaultInstance();
}

void InitDefaultsPriorBoxParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPriorBoxParameterImpl);
}

void InitDefaultsDetectionOutputParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNonMaximumSuppressionParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSaveOutputParameter();
  {
    void* ptr = &::opencv_caffe::_DetectionOutputParameter_default_instance_;
    new (ptr) ::opencv_caffe::DetectionOutputParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::DetectionOutputParameter::InitAsDefaultInstance();
}

void InitDefaultsDetectionOutputParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDetectionOutputParameterImpl);
}

void InitDefaultsDatumImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_Datum_default_instance_;
    new (ptr) ::opencv_caffe::Datum();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::Datum::InitAsDefaultInstance();
}

void InitDefaultsDatum() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDatumImpl);
}

void InitDefaultsFillerParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::opencv_caffe::FillerParameter::_default_type_.DefaultConstruct();
  *::opencv_caffe::FillerParameter::_default_type_.get_mutable() = ::std::string("constant", 8);
  ::google::protobuf::internal::OnShutdownDestroyString(
      ::opencv_caffe::FillerParameter::_default_type_.get_mutable());
  {
    void* ptr = &::opencv_caffe::_FillerParameter_default_instance_;
    new (ptr) ::opencv_caffe::FillerParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::FillerParameter::InitAsDefaultInstance();
}

void InitDefaultsFillerParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsFillerParameterImpl);
}

void InitDefaultsNetParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetState();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsLayerParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsV1LayerParameter();
  {
    void* ptr = &::opencv_caffe::_NetParameter_default_instance_;
    new (ptr) ::opencv_caffe::NetParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::NetParameter::InitAsDefaultInstance();
}

void InitDefaultsNetParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsNetParameterImpl);
}

void InitDefaultsSolverParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetState();
  ::opencv_caffe::SolverParameter::_default_regularization_type_.DefaultConstruct();
  *::opencv_caffe::SolverParameter::_default_regularization_type_.get_mutable() = ::std::string("L2", 2);
  ::google::protobuf::internal::OnShutdownDestroyString(
      ::opencv_caffe::SolverParameter::_default_regularization_type_.get_mutable());
  ::opencv_caffe::SolverParameter::_default_type_.DefaultConstruct();
  *::opencv_caffe::SolverParameter::_default_type_.get_mutable() = ::std::string("SGD", 3);
  ::google::protobuf::internal::OnShutdownDestroyString(
      ::opencv_caffe::SolverParameter::_default_type_.get_mutable());
  {
    void* ptr = &::opencv_caffe::_SolverParameter_default_instance_;
    new (ptr) ::opencv_caffe::SolverParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SolverParameter::InitAsDefaultInstance();
}

void InitDefaultsSolverParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSolverParameterImpl);
}

void InitDefaultsSolverStateImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  {
    void* ptr = &::opencv_caffe::_SolverState_default_instance_;
    new (ptr) ::opencv_caffe::SolverState();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SolverState::InitAsDefaultInstance();
}

void InitDefaultsSolverState() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSolverStateImpl);
}

void InitDefaultsNetStateImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_NetState_default_instance_;
    new (ptr) ::opencv_caffe::NetState();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::NetState::InitAsDefaultInstance();
}

void InitDefaultsNetState() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsNetStateImpl);
}

void InitDefaultsNetStateRuleImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_NetStateRule_default_instance_;
    new (ptr) ::opencv_caffe::NetStateRule();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::NetStateRule::InitAsDefaultInstance();
}

void InitDefaultsNetStateRule() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsNetStateRuleImpl);
}

void InitDefaultsParamSpecImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ParamSpec_default_instance_;
    new (ptr) ::opencv_caffe::ParamSpec();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ParamSpec::InitAsDefaultInstance();
}

void InitDefaultsParamSpec() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsParamSpecImpl);
}

void InitDefaultsLayerParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsParamSpec();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetStateRule();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsTransformationParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsAccuracyParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsArgMaxParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBatchNormParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBiasParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsConcatParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsContrastiveLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsConvolutionParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsCropParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDetectionOutputParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDropoutParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDummyDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsEltwiseParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsELUParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsEmbedParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsExpParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFlattenParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5DataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5OutputParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHingeLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsImageDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsInfogainLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsInnerProductParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsInputParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsLogParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsLRNParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsMemoryDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsMVNParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizeBBoxParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPermuteParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsParameterParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPoolingParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPowerParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPReLUParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPriorBoxParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsProposalParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPSROIPoolingParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPythonParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsRecurrentParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsReductionParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsReLUParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsReshapeParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsROIPoolingParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsScaleParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSigmoidParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSoftmaxParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSPPParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSliceParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsTanHParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsThresholdParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsTileParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsWindowDataParameter();
  {
    void* ptr = &::opencv_caffe::_LayerParameter_default_instance_;
    new (ptr) ::opencv_caffe::LayerParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::LayerParameter::InitAsDefaultInstance();
}

void InitDefaultsLayerParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsLayerParameterImpl);
}

void InitDefaultsTransformationParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_TransformationParameter_default_instance_;
    new (ptr) ::opencv_caffe::TransformationParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::TransformationParameter::InitAsDefaultInstance();
}

void InitDefaultsTransformationParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTransformationParameterImpl);
}

void InitDefaultsLossParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_LossParameter_default_instance_;
    new (ptr) ::opencv_caffe::LossParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::LossParameter::InitAsDefaultInstance();
}

void InitDefaultsLossParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsLossParameterImpl);
}

void InitDefaultsAccuracyParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_AccuracyParameter_default_instance_;
    new (ptr) ::opencv_caffe::AccuracyParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::AccuracyParameter::InitAsDefaultInstance();
}

void InitDefaultsAccuracyParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsAccuracyParameterImpl);
}

void InitDefaultsArgMaxParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ArgMaxParameter_default_instance_;
    new (ptr) ::opencv_caffe::ArgMaxParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ArgMaxParameter::InitAsDefaultInstance();
}

void InitDefaultsArgMaxParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsArgMaxParameterImpl);
}

void InitDefaultsConcatParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ConcatParameter_default_instance_;
    new (ptr) ::opencv_caffe::ConcatParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ConcatParameter::InitAsDefaultInstance();
}

void InitDefaultsConcatParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsConcatParameterImpl);
}

void InitDefaultsBatchNormParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_BatchNormParameter_default_instance_;
    new (ptr) ::opencv_caffe::BatchNormParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::BatchNormParameter::InitAsDefaultInstance();
}

void InitDefaultsBatchNormParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsBatchNormParameterImpl);
}

void InitDefaultsBiasParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_BiasParameter_default_instance_;
    new (ptr) ::opencv_caffe::BiasParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::BiasParameter::InitAsDefaultInstance();
}

void InitDefaultsBiasParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsBiasParameterImpl);
}

void InitDefaultsContrastiveLossParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ContrastiveLossParameter_default_instance_;
    new (ptr) ::opencv_caffe::ContrastiveLossParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ContrastiveLossParameter::InitAsDefaultInstance();
}

void InitDefaultsContrastiveLossParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsContrastiveLossParameterImpl);
}

void InitDefaultsConvolutionParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_ConvolutionParameter_default_instance_;
    new (ptr) ::opencv_caffe::ConvolutionParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ConvolutionParameter::InitAsDefaultInstance();
}

void InitDefaultsConvolutionParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsConvolutionParameterImpl);
}

void InitDefaultsCropParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_CropParameter_default_instance_;
    new (ptr) ::opencv_caffe::CropParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::CropParameter::InitAsDefaultInstance();
}

void InitDefaultsCropParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsCropParameterImpl);
}

void InitDefaultsDataParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_DataParameter_default_instance_;
    new (ptr) ::opencv_caffe::DataParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::DataParameter::InitAsDefaultInstance();
}

void InitDefaultsDataParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDataParameterImpl);
}

void InitDefaultsNonMaximumSuppressionParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_;
    new (ptr) ::opencv_caffe::NonMaximumSuppressionParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::NonMaximumSuppressionParameter::InitAsDefaultInstance();
}

void InitDefaultsNonMaximumSuppressionParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsNonMaximumSuppressionParameterImpl);
}

void InitDefaultsSaveOutputParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_SaveOutputParameter_default_instance_;
    new (ptr) ::opencv_caffe::SaveOutputParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SaveOutputParameter::InitAsDefaultInstance();
}

void InitDefaultsSaveOutputParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSaveOutputParameterImpl);
}

void InitDefaultsDropoutParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_DropoutParameter_default_instance_;
    new (ptr) ::opencv_caffe::DropoutParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::DropoutParameter::InitAsDefaultInstance();
}

void InitDefaultsDropoutParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDropoutParameterImpl);
}

void InitDefaultsDummyDataParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  {
    void* ptr = &::opencv_caffe::_DummyDataParameter_default_instance_;
    new (ptr) ::opencv_caffe::DummyDataParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::DummyDataParameter::InitAsDefaultInstance();
}

void InitDefaultsDummyDataParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDummyDataParameterImpl);
}

void InitDefaultsEltwiseParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_EltwiseParameter_default_instance_;
    new (ptr) ::opencv_caffe::EltwiseParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::EltwiseParameter::InitAsDefaultInstance();
}

void InitDefaultsEltwiseParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEltwiseParameterImpl);
}

void InitDefaultsELUParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ELUParameter_default_instance_;
    new (ptr) ::opencv_caffe::ELUParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ELUParameter::InitAsDefaultInstance();
}

void InitDefaultsELUParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsELUParameterImpl);
}

void InitDefaultsEmbedParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_EmbedParameter_default_instance_;
    new (ptr) ::opencv_caffe::EmbedParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::EmbedParameter::InitAsDefaultInstance();
}

void InitDefaultsEmbedParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEmbedParameterImpl);
}

void InitDefaultsExpParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ExpParameter_default_instance_;
    new (ptr) ::opencv_caffe::ExpParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ExpParameter::InitAsDefaultInstance();
}

void InitDefaultsExpParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsExpParameterImpl);
}

void InitDefaultsFlattenParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_FlattenParameter_default_instance_;
    new (ptr) ::opencv_caffe::FlattenParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::FlattenParameter::InitAsDefaultInstance();
}

void InitDefaultsFlattenParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsFlattenParameterImpl);
}

void InitDefaultsHDF5DataParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_HDF5DataParameter_default_instance_;
    new (ptr) ::opencv_caffe::HDF5DataParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::HDF5DataParameter::InitAsDefaultInstance();
}

void InitDefaultsHDF5DataParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsHDF5DataParameterImpl);
}

void InitDefaultsHDF5OutputParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_HDF5OutputParameter_default_instance_;
    new (ptr) ::opencv_caffe::HDF5OutputParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::HDF5OutputParameter::InitAsDefaultInstance();
}

void InitDefaultsHDF5OutputParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsHDF5OutputParameterImpl);
}

void InitDefaultsHingeLossParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_HingeLossParameter_default_instance_;
    new (ptr) ::opencv_caffe::HingeLossParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::HingeLossParameter::InitAsDefaultInstance();
}

void InitDefaultsHingeLossParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsHingeLossParameterImpl);
}

void InitDefaultsImageDataParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ImageDataParameter_default_instance_;
    new (ptr) ::opencv_caffe::ImageDataParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ImageDataParameter::InitAsDefaultInstance();
}

void InitDefaultsImageDataParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsImageDataParameterImpl);
}

void InitDefaultsInfogainLossParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_InfogainLossParameter_default_instance_;
    new (ptr) ::opencv_caffe::InfogainLossParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::InfogainLossParameter::InitAsDefaultInstance();
}

void InitDefaultsInfogainLossParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsInfogainLossParameterImpl);
}

void InitDefaultsInnerProductParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_InnerProductParameter_default_instance_;
    new (ptr) ::opencv_caffe::InnerProductParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::InnerProductParameter::InitAsDefaultInstance();
}

void InitDefaultsInnerProductParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsInnerProductParameterImpl);
}

void InitDefaultsInputParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  {
    void* ptr = &::opencv_caffe::_InputParameter_default_instance_;
    new (ptr) ::opencv_caffe::InputParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::InputParameter::InitAsDefaultInstance();
}

void InitDefaultsInputParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsInputParameterImpl);
}

void InitDefaultsLogParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_LogParameter_default_instance_;
    new (ptr) ::opencv_caffe::LogParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::LogParameter::InitAsDefaultInstance();
}

void InitDefaultsLogParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsLogParameterImpl);
}

void InitDefaultsLRNParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_LRNParameter_default_instance_;
    new (ptr) ::opencv_caffe::LRNParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::LRNParameter::InitAsDefaultInstance();
}

void InitDefaultsLRNParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsLRNParameterImpl);
}

void InitDefaultsMemoryDataParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_MemoryDataParameter_default_instance_;
    new (ptr) ::opencv_caffe::MemoryDataParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::MemoryDataParameter::InitAsDefaultInstance();
}

void InitDefaultsMemoryDataParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsMemoryDataParameterImpl);
}

void InitDefaultsMVNParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_MVNParameter_default_instance_;
    new (ptr) ::opencv_caffe::MVNParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::MVNParameter::InitAsDefaultInstance();
}

void InitDefaultsMVNParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsMVNParameterImpl);
}

void InitDefaultsParameterParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  {
    void* ptr = &::opencv_caffe::_ParameterParameter_default_instance_;
    new (ptr) ::opencv_caffe::ParameterParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ParameterParameter::InitAsDefaultInstance();
}

void InitDefaultsParameterParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsParameterParameterImpl);
}

void InitDefaultsPoolingParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_PoolingParameter_default_instance_;
    new (ptr) ::opencv_caffe::PoolingParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PoolingParameter::InitAsDefaultInstance();
}

void InitDefaultsPoolingParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPoolingParameterImpl);
}

void InitDefaultsPowerParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_PowerParameter_default_instance_;
    new (ptr) ::opencv_caffe::PowerParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PowerParameter::InitAsDefaultInstance();
}

void InitDefaultsPowerParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPowerParameterImpl);
}

void InitDefaultsPythonParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_PythonParameter_default_instance_;
    new (ptr) ::opencv_caffe::PythonParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PythonParameter::InitAsDefaultInstance();
}

void InitDefaultsPythonParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPythonParameterImpl);
}

void InitDefaultsRecurrentParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_RecurrentParameter_default_instance_;
    new (ptr) ::opencv_caffe::RecurrentParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::RecurrentParameter::InitAsDefaultInstance();
}

void InitDefaultsRecurrentParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRecurrentParameterImpl);
}

void InitDefaultsReductionParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ReductionParameter_default_instance_;
    new (ptr) ::opencv_caffe::ReductionParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ReductionParameter::InitAsDefaultInstance();
}

void InitDefaultsReductionParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsReductionParameterImpl);
}

void InitDefaultsReLUParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ReLUParameter_default_instance_;
    new (ptr) ::opencv_caffe::ReLUParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ReLUParameter::InitAsDefaultInstance();
}

void InitDefaultsReLUParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsReLUParameterImpl);
}

void InitDefaultsReshapeParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  {
    void* ptr = &::opencv_caffe::_ReshapeParameter_default_instance_;
    new (ptr) ::opencv_caffe::ReshapeParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ReshapeParameter::InitAsDefaultInstance();
}

void InitDefaultsReshapeParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsReshapeParameterImpl);
}

void InitDefaultsScaleParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_ScaleParameter_default_instance_;
    new (ptr) ::opencv_caffe::ScaleParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ScaleParameter::InitAsDefaultInstance();
}

void InitDefaultsScaleParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsScaleParameterImpl);
}

void InitDefaultsSigmoidParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_SigmoidParameter_default_instance_;
    new (ptr) ::opencv_caffe::SigmoidParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SigmoidParameter::InitAsDefaultInstance();
}

void InitDefaultsSigmoidParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSigmoidParameterImpl);
}

void InitDefaultsSliceParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_SliceParameter_default_instance_;
    new (ptr) ::opencv_caffe::SliceParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SliceParameter::InitAsDefaultInstance();
}

void InitDefaultsSliceParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSliceParameterImpl);
}

void InitDefaultsSoftmaxParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_SoftmaxParameter_default_instance_;
    new (ptr) ::opencv_caffe::SoftmaxParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SoftmaxParameter::InitAsDefaultInstance();
}

void InitDefaultsSoftmaxParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSoftmaxParameterImpl);
}

void InitDefaultsTanHParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_TanHParameter_default_instance_;
    new (ptr) ::opencv_caffe::TanHParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::TanHParameter::InitAsDefaultInstance();
}

void InitDefaultsTanHParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTanHParameterImpl);
}

void InitDefaultsTileParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_TileParameter_default_instance_;
    new (ptr) ::opencv_caffe::TileParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::TileParameter::InitAsDefaultInstance();
}

void InitDefaultsTileParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTileParameterImpl);
}

void InitDefaultsThresholdParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ThresholdParameter_default_instance_;
    new (ptr) ::opencv_caffe::ThresholdParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ThresholdParameter::InitAsDefaultInstance();
}

void InitDefaultsThresholdParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsThresholdParameterImpl);
}

void InitDefaultsWindowDataParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::opencv_caffe::WindowDataParameter::_default_crop_mode_.DefaultConstruct();
  *::opencv_caffe::WindowDataParameter::_default_crop_mode_.get_mutable() = ::std::string("warp", 4);
  ::google::protobuf::internal::OnShutdownDestroyString(
      ::opencv_caffe::WindowDataParameter::_default_crop_mode_.get_mutable());
  {
    void* ptr = &::opencv_caffe::_WindowDataParameter_default_instance_;
    new (ptr) ::opencv_caffe::WindowDataParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::WindowDataParameter::InitAsDefaultInstance();
}

void InitDefaultsWindowDataParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsWindowDataParameterImpl);
}

void InitDefaultsSPPParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_SPPParameter_default_instance_;
    new (ptr) ::opencv_caffe::SPPParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::SPPParameter::InitAsDefaultInstance();
}

void InitDefaultsSPPParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSPPParameterImpl);
}

void InitDefaultsV1LayerParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetStateRule();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsAccuracyParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsArgMaxParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsConcatParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsContrastiveLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsConvolutionParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDropoutParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsDummyDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsEltwiseParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsExpParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5DataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5OutputParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHingeLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsImageDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsInfogainLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsInnerProductParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsLRNParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsMemoryDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsMVNParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPoolingParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsPowerParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsReLUParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSigmoidParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSoftmaxParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsSliceParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsTanHParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsThresholdParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsWindowDataParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsTransformationParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsLossParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsV0LayerParameter();
  {
    void* ptr = &::opencv_caffe::_V1LayerParameter_default_instance_;
    new (ptr) ::opencv_caffe::V1LayerParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::V1LayerParameter::InitAsDefaultInstance();
}

void InitDefaultsV1LayerParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsV1LayerParameterImpl);
}

void InitDefaultsV0LayerParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5OutputParameter();
  ::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.DefaultConstruct();
  *::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get_mutable() = ::std::string("warp", 4);
  ::google::protobuf::internal::OnShutdownDestroyString(
      ::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get_mutable());
  {
    void* ptr = &::opencv_caffe::_V0LayerParameter_default_instance_;
    new (ptr) ::opencv_caffe::V0LayerParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::V0LayerParameter::InitAsDefaultInstance();
}

void InitDefaultsV0LayerParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsV0LayerParameterImpl);
}

void InitDefaultsPReLUParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  {
    void* ptr = &::opencv_caffe::_PReLUParameter_default_instance_;
    new (ptr) ::opencv_caffe::PReLUParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PReLUParameter::InitAsDefaultInstance();
}

void InitDefaultsPReLUParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPReLUParameterImpl);
}

void InitDefaultsNormalizedBBoxImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_NormalizedBBox_default_instance_;
    new (ptr) ::opencv_caffe::NormalizedBBox();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::NormalizedBBox::InitAsDefaultInstance();
}

void InitDefaultsNormalizedBBox() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsNormalizedBBoxImpl);
}

void InitDefaultsROIPoolingParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ROIPoolingParameter_default_instance_;
    new (ptr) ::opencv_caffe::ROIPoolingParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ROIPoolingParameter::InitAsDefaultInstance();
}

void InitDefaultsROIPoolingParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsROIPoolingParameterImpl);
}

void InitDefaultsProposalParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_ProposalParameter_default_instance_;
    new (ptr) ::opencv_caffe::ProposalParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::ProposalParameter::InitAsDefaultInstance();
}

void InitDefaultsProposalParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsProposalParameterImpl);
}

void InitDefaultsPSROIPoolingParameterImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::opencv_caffe::_PSROIPoolingParameter_default_instance_;
    new (ptr) ::opencv_caffe::PSROIPoolingParameter();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::opencv_caffe::PSROIPoolingParameter::InitAsDefaultInstance();
}

void InitDefaultsPSROIPoolingParameter() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPSROIPoolingParameterImpl);
}

::google::protobuf::Metadata file_level_metadata[71];
const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[27];

const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobShape, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobShape, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobShape, dim_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, shape_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, data_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, diff_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, double_data_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, double_diff_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, raw_data_type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, raw_data_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, num_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, channels_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProto, width_),
  1,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  6,
  0,
  2,
  3,
  4,
  5,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BlobProtoVector, blobs_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PermuteParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PermuteParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PermuteParameter, order_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, across_spatial_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, scale_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, channel_shared_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizeBBoxParameter, eps_),
  1,
  0,
  2,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, min_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, max_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, aspect_ratio_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, flip_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, clip_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, variance_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, img_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, step_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, offset_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, width_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PriorBoxParameter, height_),
  0,
  1,
  ~0u,
  8,
  9,
  ~0u,
  2,
  3,
  4,
  5,
  6,
  7,
  10,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, num_classes_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, share_location_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, background_label_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, nms_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, save_output_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, code_type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, variance_encoded_in_target_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, keep_top_k_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, confidence_threshold_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DetectionOutputParameter, normalized_bbox_),
  2,
  8,
  3,
  0,
  1,
  7,
  4,
  6,
  5,
  9,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, channels_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, width_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, data_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, label_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, float_data_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::Datum, encoded_),
  1,
  2,
  3,
  0,
  4,
  ~0u,
  5,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, value_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, min_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, max_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, mean_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, std_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, sparse_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FillerParameter, variance_norm_),
  0,
  1,
  2,
  6,
  3,
  7,
  5,
  4,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, name_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, input_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, input_shape_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, input_dim_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, force_backward_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, state_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, debug_info_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, layer_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetParameter, layers_),
  0,
  ~0u,
  ~0u,
  ~0u,
  2,
  1,
  3,
  ~0u,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, net_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, net_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_net_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_net_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_net_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_net_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, train_state_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_state_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_iter_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_interval_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_compute_loss_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, test_initialization_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, base_lr_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, display_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, average_loss_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, max_iter_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, iter_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, lr_policy_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, gamma_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, power_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, momentum_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, weight_decay_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, regularization_type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, stepsize_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, stepvalue_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, clip_gradients_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_prefix_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_diff_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_format_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, solver_mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, device_id_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, random_seed_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, delta_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, momentum2_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, rms_decay_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, debug_info_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, snapshot_after_train_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverParameter, solver_type_),
  3,
  7,
  0,
  ~0u,
  6,
  ~0u,
  8,
  ~0u,
  ~0u,
  9,
  20,
  27,
  10,
  11,
  30,
  12,
  32,
  1,
  13,
  14,
  15,
  16,
  4,
  17,
  ~0u,
  31,
  18,
  2,
  21,
  33,
  26,
  19,
  25,
  5,
  29,
  24,
  34,
  22,
  28,
  23,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverState, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverState, iter_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverState, learned_net_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverState, history_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SolverState, current_step_),
  1,
  0,
  ~0u,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetState, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetState, phase_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetState, level_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetState, stage_),
  1,
  0,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, phase_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, min_level_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, max_level_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, stage_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NetStateRule, not_stage_),
  0,
  1,
  2,
  ~0u,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParamSpec, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParamSpec, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParamSpec, name_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParamSpec, share_mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParamSpec, lr_mult_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParamSpec, decay_mult_),
  0,
  1,
  2,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, name_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, bottom_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, top_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, phase_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, loss_weight_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, blobs_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, propagate_down_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, include_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, exclude_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, transform_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, accuracy_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, argmax_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, batch_norm_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, bias_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, concat_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, contrastive_loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, convolution_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, crop_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, detection_output_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, dropout_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, dummy_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, eltwise_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, elu_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, embed_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, exp_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, flatten_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, hdf5_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, hdf5_output_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, hinge_loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, image_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, infogain_loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, inner_product_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, input_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, log_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, lrn_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, memory_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, mvn_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, norm_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, permute_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, parameter_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, pooling_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, power_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, prelu_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, prior_box_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, proposal_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, psroi_pooling_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, python_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, recurrent_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, reduction_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, relu_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, reshape_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, roi_pooling_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, scale_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, sigmoid_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, softmax_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, spp_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, slice_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, tanh_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, threshold_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, tile_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LayerParameter, window_data_param_),
  0,
  1,
  ~0u,
  ~0u,
  56,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  2,
  3,
  4,
  5,
  41,
  43,
  6,
  7,
  8,
  46,
  9,
  49,
  10,
  11,
  12,
  42,
  39,
  13,
  37,
  14,
  15,
  16,
  17,
  18,
  19,
  45,
  36,
  20,
  21,
  22,
  51,
  50,
  47,
  23,
  24,
  33,
  52,
  53,
  54,
  32,
  48,
  38,
  25,
  35,
  55,
  44,
  26,
  27,
  34,
  28,
  29,
  30,
  40,
  31,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mirror_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, crop_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mean_file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, mean_value_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, force_color_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TransformationParameter, force_gray_),
  5,
  2,
  1,
  0,
  ~0u,
  3,
  4,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LossParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LossParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LossParameter, ignore_label_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LossParameter, normalization_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LossParameter, normalize_),
  0,
  2,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, top_k_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::AccuracyParameter, ignore_label_),
  1,
  2,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, out_max_val_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, top_k_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ArgMaxParameter, axis_),
  0,
  2,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConcatParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConcatParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConcatParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConcatParameter, concat_dim_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, use_global_stats_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, moving_average_fraction_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, eps_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BatchNormParameter, scale_bias_),
  0,
  2,
  3,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BiasParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BiasParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BiasParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BiasParameter, num_axes_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::BiasParameter, filler_),
  1,
  2,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, margin_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ContrastiveLossParameter, legacy_version_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, num_output_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, bias_term_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, dilation_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, pad_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, kernel_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, stride_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, group_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, weight_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, bias_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, engine_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ConvolutionParameter, force_nd_im2col_),
  2,
  12,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  3,
  4,
  5,
  6,
  7,
  8,
  13,
  0,
  1,
  9,
  11,
  10,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::CropParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::CropParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::CropParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::CropParameter, offset_),
  0,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, source_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, batch_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, rand_skip_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, backend_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, mean_file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, crop_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, mirror_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, force_encoded_color_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DataParameter, prefetch_),
  0,
  2,
  4,
  7,
  8,
  1,
  3,
  5,
  6,
  9,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, nms_threshold_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, top_k_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NonMaximumSuppressionParameter, eta_),
  1,
  0,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_directory_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_name_prefix_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, output_format_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, label_map_file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, name_size_file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SaveOutputParameter, num_test_image_),
  0,
  1,
  2,
  3,
  4,
  5,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DropoutParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DropoutParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DropoutParameter, dropout_ratio_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DropoutParameter, scale_train_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, data_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, shape_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, num_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, channels_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::DummyDataParameter, width_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, operation_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, coeff_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EltwiseParameter, stable_prod_grad_),
  0,
  ~0u,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ELUParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ELUParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ELUParameter, alpha_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, num_output_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, input_dim_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, bias_term_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, weight_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::EmbedParameter, bias_filler_),
  2,
  3,
  4,
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ExpParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ExpParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ExpParameter, base_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ExpParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ExpParameter, shift_),
  1,
  2,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FlattenParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FlattenParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FlattenParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::FlattenParameter, end_axis_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, source_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, batch_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5DataParameter, shuffle_),
  0,
  1,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HDF5OutputParameter, file_name_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::HingeLossParameter, norm_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, source_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, batch_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, rand_skip_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, shuffle_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, new_height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, new_width_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, is_color_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, mean_file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, crop_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, mirror_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ImageDataParameter, root_folder_),
  0,
  11,
  4,
  5,
  7,
  8,
  9,
  10,
  1,
  3,
  6,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InfogainLossParameter, source_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, num_output_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, bias_term_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, weight_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, bias_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InnerProductParameter, transpose_),
  2,
  4,
  0,
  1,
  5,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InputParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InputParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::InputParameter, shape_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LogParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LogParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LogParameter, base_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LogParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LogParameter, shift_),
  1,
  2,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, local_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, alpha_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, beta_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, norm_region_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, k_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::LRNParameter, engine_),
  2,
  3,
  4,
  0,
  5,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, batch_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, channels_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MemoryDataParameter, width_),
  0,
  1,
  2,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MVNParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MVNParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MVNParameter, normalize_variance_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MVNParameter, across_channels_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::MVNParameter, eps_),
  1,
  0,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParameterParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParameterParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ParameterParameter, shape_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pool_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, pad_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, kernel_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, stride_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, engine_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, global_pooling_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PoolingParameter, ceil_mode_),
  0,
  2,
  7,
  8,
  1,
  3,
  4,
  11,
  5,
  6,
  9,
  10,
  12,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PowerParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PowerParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PowerParameter, power_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PowerParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PowerParameter, shift_),
  1,
  2,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PythonParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PythonParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PythonParameter, module_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PythonParameter, layer_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PythonParameter, param_str_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PythonParameter, share_in_parallel_),
  0,
  1,
  2,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, num_output_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, weight_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, bias_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, debug_info_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::RecurrentParameter, expose_hidden_),
  2,
  0,
  1,
  3,
  4,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReductionParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReductionParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReductionParameter, operation_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReductionParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReductionParameter, coeff_),
  1,
  0,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReLUParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReLUParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReLUParameter, negative_slope_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReLUParameter, engine_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, shape_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ReshapeParameter, num_axes_),
  0,
  1,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, num_axes_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, bias_term_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ScaleParameter, bias_filler_),
  3,
  4,
  0,
  2,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SigmoidParameter, engine_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SliceParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SliceParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SliceParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SliceParameter, slice_point_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SliceParameter, slice_dim_),
  1,
  ~0u,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, engine_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SoftmaxParameter, axis_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TanHParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TanHParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TanHParameter, engine_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TileParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TileParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TileParameter, axis_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::TileParameter, tiles_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ThresholdParameter, threshold_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, source_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, mean_file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, batch_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, crop_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, mirror_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, fg_threshold_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, bg_threshold_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, fg_fraction_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, context_pad_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, crop_mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, cache_images_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::WindowDataParameter, root_folder_),
  0,
  9,
  1,
  4,
  5,
  6,
  10,
  11,
  12,
  8,
  2,
  7,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SPPParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SPPParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SPPParameter, pyramid_height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SPPParameter, pool_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::SPPParameter, engine_),
  0,
  1,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, bottom_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, top_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, name_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, include_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, exclude_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blobs_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blob_share_mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, blobs_lr_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, weight_decay_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, loss_weight_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, accuracy_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, argmax_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, concat_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, contrastive_loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, convolution_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, dropout_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, dummy_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, eltwise_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, exp_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hdf5_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hdf5_output_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, hinge_loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, image_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, infogain_loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, inner_product_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, lrn_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, memory_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, mvn_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, pooling_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, power_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, relu_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, sigmoid_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, softmax_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, slice_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, tanh_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, threshold_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, window_data_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, transform_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, loss_param_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V1LayerParameter, layer_),
  ~0u,
  ~0u,
  0,
  ~0u,
  ~0u,
  32,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  20,
  16,
  2,
  29,
  3,
  4,
  5,
  19,
  17,
  30,
  6,
  7,
  21,
  8,
  9,
  10,
  11,
  15,
  24,
  12,
  14,
  22,
  27,
  28,
  23,
  26,
  18,
  13,
  25,
  31,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, name_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, num_output_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, biasterm_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, weight_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, bias_filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, pad_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, kernelsize_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, group_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, stride_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, pool_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, dropout_ratio_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, local_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, alpha_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, beta_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, k_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, source_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, meanfile_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, batchsize_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, cropsize_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, mirror_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, blobs_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, blobs_lr_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, weight_decay_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, rand_skip_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_fg_threshold_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_bg_threshold_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_fg_fraction_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_context_pad_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, det_crop_mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_num_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_channels_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_height_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, new_width_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, shuffle_images_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, concat_dim_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::V0LayerParameter, hdf5_output_param_),
  0,
  1,
  8,
  23,
  5,
  6,
  9,
  10,
  24,
  25,
  11,
  26,
  27,
  28,
  29,
  31,
  2,
  30,
  3,
  12,
  13,
  15,
  ~0u,
  ~0u,
  ~0u,
  17,
  32,
  33,
  34,
  18,
  4,
  19,
  20,
  21,
  14,
  16,
  22,
  7,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PReLUParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PReLUParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PReLUParameter, filler_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PReLUParameter, channel_shared_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, xmin_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, ymin_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, xmax_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, ymax_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, label_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, difficult_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, score_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::NormalizedBBox, size_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, pooled_h_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, pooled_w_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ROIPoolingParameter, spatial_scale_),
  0,
  1,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, feat_stride_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, base_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, min_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, ratio_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, pre_nms_topn_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, post_nms_topn_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::ProposalParameter, nms_thresh_),
  0,
  1,
  2,
  ~0u,
  ~0u,
  3,
  4,
  5,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, spatial_scale_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, output_dim_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_caffe::PSROIPoolingParameter, group_size_),
  0,
  1,
  2,
};
static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 6, sizeof(::opencv_caffe::BlobShape)},
  { 7, 23, sizeof(::opencv_caffe::BlobProto)},
  { 34, 40, sizeof(::opencv_caffe::BlobProtoVector)},
  { 41, 47, sizeof(::opencv_caffe::PermuteParameter)},
  { 48, 57, sizeof(::opencv_caffe::NormalizeBBoxParameter)},
  { 61, 83, sizeof(::opencv_caffe::PriorBoxParameter)},
  { 100, 115, sizeof(::opencv_caffe::DetectionOutputParameter)},
  { 125, 137, sizeof(::opencv_caffe::Datum)},
  { 144, 157, sizeof(::opencv_caffe::FillerParameter)},
  { 165, 179, sizeof(::opencv_caffe::NetParameter)},
  { 188, 233, sizeof(::opencv_caffe::SolverParameter)},
  { 273, 282, sizeof(::opencv_caffe::SolverState)},
  { 286, 294, sizeof(::opencv_caffe::NetState)},
  { 297, 307, sizeof(::opencv_caffe::NetStateRule)},
  { 312, 321, sizeof(::opencv_caffe::ParamSpec)},
  { 325, 395, sizeof(::opencv_caffe::LayerParameter)},
  { 460, 472, sizeof(::opencv_caffe::TransformationParameter)},
  { 479, 487, sizeof(::opencv_caffe::LossParameter)},
  { 490, 498, sizeof(::opencv_caffe::AccuracyParameter)},
  { 501, 509, sizeof(::opencv_caffe::ArgMaxParameter)},
  { 512, 519, sizeof(::opencv_caffe::ConcatParameter)},
  { 521, 530, sizeof(::opencv_caffe::BatchNormParameter)},
  { 534, 542, sizeof(::opencv_caffe::BiasParameter)},
  { 545, 552, sizeof(::opencv_caffe::ContrastiveLossParameter)},
  { 554, 577, sizeof(::opencv_caffe::ConvolutionParameter)},
  { 595, 602, sizeof(::opencv_caffe::CropParameter)},
  { 604, 619, sizeof(::opencv_caffe::DataParameter)},
  { 629, 637, sizeof(::opencv_caffe::NonMaximumSuppressionParameter)},
  { 640, 651, sizeof(::opencv_caffe::SaveOutputParameter)},
  { 657, 664, sizeof(::opencv_caffe::DropoutParameter)},
  { 666, 677, sizeof(::opencv_caffe::DummyDataParameter)},
  { 683, 691, sizeof(::opencv_caffe::EltwiseParameter)},
  { 694, 700, sizeof(::opencv_caffe::ELUParameter)},
  { 701, 711, sizeof(::opencv_caffe::EmbedParameter)},
  { 716, 724, sizeof(::opencv_caffe::ExpParameter)},
  { 727, 734, sizeof(::opencv_caffe::FlattenParameter)},
  { 736, 744, sizeof(::opencv_caffe::HDF5DataParameter)},
  { 747, 753, sizeof(::opencv_caffe::HDF5OutputParameter)},
  { 754, 760, sizeof(::opencv_caffe::HingeLossParameter)},
  { 761, 778, sizeof(::opencv_caffe::ImageDataParameter)},
  { 790, 796, sizeof(::opencv_caffe::InfogainLossParameter)},
  { 797, 808, sizeof(::opencv_caffe::InnerProductParameter)},
  { 814, 820, sizeof(::opencv_caffe::InputParameter)},
  { 821, 829, sizeof(::opencv_caffe::LogParameter)},
  { 832, 843, sizeof(::opencv_caffe::LRNParameter)},
  { 849, 858, sizeof(::opencv_caffe::MemoryDataParameter)},
  { 862, 870, sizeof(::opencv_caffe::MVNParameter)},
  { 873, 879, sizeof(::opencv_caffe::ParameterParameter)},
  { 880, 898, sizeof(::opencv_caffe::PoolingParameter)},
  { 911, 919, sizeof(::opencv_caffe::PowerParameter)},
  { 922, 931, sizeof(::opencv_caffe::PythonParameter)},
  { 935, 945, sizeof(::opencv_caffe::RecurrentParameter)},
  { 950, 958, sizeof(::opencv_caffe::ReductionParameter)},
  { 961, 968, sizeof(::opencv_caffe::ReLUParameter)},
  { 970, 978, sizeof(::opencv_caffe::ReshapeParameter)},
  { 981, 991, sizeof(::opencv_caffe::ScaleParameter)},
  { 996, 1002, sizeof(::opencv_caffe::SigmoidParameter)},
  { 1003, 1011, sizeof(::opencv_caffe::SliceParameter)},
  { 1014, 1021, sizeof(::opencv_caffe::SoftmaxParameter)},
  { 1023, 1029, sizeof(::opencv_caffe::TanHParameter)},
  { 1030, 1037, sizeof(::opencv_caffe::TileParameter)},
  { 1039, 1045, sizeof(::opencv_caffe::ThresholdParameter)},
  { 1046, 1064, sizeof(::opencv_caffe::WindowDataParameter)},
  { 1077, 1085, sizeof(::opencv_caffe::SPPParameter)},
  { 1088, 1136, sizeof(::opencv_caffe::V1LayerParameter)},
  { 1179, 1222, sizeof(::opencv_caffe::V0LayerParameter)},
  { 1260, 1267, sizeof(::opencv_caffe::PReLUParameter)},
  { 1269, 1282, sizeof(::opencv_caffe::NormalizedBBox)},
  { 1290, 1298, sizeof(::opencv_caffe::ROIPoolingParameter)},
  { 1301, 1314, sizeof(::opencv_caffe::ProposalParameter)},
  { 1322, 1330, sizeof(::opencv_caffe::PSROIPoolingParameter)},
};

static ::google::protobuf::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_BlobShape_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_BlobProto_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_BlobProtoVector_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PermuteParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_NormalizeBBoxParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PriorBoxParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_DetectionOutputParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_Datum_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_FillerParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_NetParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SolverParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SolverState_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_NetState_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_NetStateRule_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ParamSpec_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_LayerParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_TransformationParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_LossParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_AccuracyParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ArgMaxParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ConcatParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_BatchNormParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_BiasParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ContrastiveLossParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ConvolutionParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_CropParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_DataParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_NonMaximumSuppressionParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SaveOutputParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_DropoutParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_DummyDataParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_EltwiseParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ELUParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_EmbedParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ExpParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_FlattenParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_HDF5DataParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_HDF5OutputParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_HingeLossParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ImageDataParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_InfogainLossParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_InnerProductParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_InputParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_LogParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_LRNParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_MemoryDataParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_MVNParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ParameterParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PoolingParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PowerParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PythonParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_RecurrentParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ReductionParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ReLUParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ReshapeParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ScaleParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SigmoidParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SliceParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SoftmaxParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_TanHParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_TileParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ThresholdParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_WindowDataParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_SPPParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_V1LayerParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_V0LayerParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PReLUParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_NormalizedBBox_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ROIPoolingParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_ProposalParameter_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_caffe::_PSROIPoolingParameter_default_instance_),
};

void protobuf_AssignDescriptors() {
  AddDescriptors();
  ::google::protobuf::MessageFactory* factory = NULL;
  AssignDescriptors(
      "opencv-caffe.proto", schemas, file_default_instances, TableStruct::offsets, factory,
      file_level_metadata, file_level_enum_descriptors, NULL);
}

void protobuf_AssignDescriptorsOnce() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 71);
}

void AddDescriptorsImpl() {
  InitDefaults();
  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
      "\n\022opencv-caffe.proto\022\014opencv_caffe\"\034\n\tBl"
      "obShape\022\017\n\003dim\030\001 \003(\003B\002\020\001\"\224\002\n\tBlobProto\022&"
      "\n\005shape\030\007 \001(\0132\027.opencv_caffe.BlobShape\022\020"
      "\n\004data\030\005 \003(\002B\002\020\001\022\020\n\004diff\030\006 \003(\002B\002\020\001\022\027\n\013do"
      "uble_data\030\010 \003(\001B\002\020\001\022\027\n\013double_diff\030\t \003(\001"
      "B\002\020\001\022)\n\rraw_data_type\030\n \001(\0162\022.opencv_caf"
      "fe.Type\022\024\n\010raw_data\030\014 \001(\014B\002\020\000\022\016\n\003num\030\001 \001"
      "(\005:\0010\022\023\n\010channels\030\002 \001(\005:\0010\022\021\n\006height\030\003 \001"
      "(\005:\0010\022\020\n\005width\030\004 \001(\005:\0010\"9\n\017BlobProtoVect"
      "or\022&\n\005blobs\030\001 \003(\0132\027.opencv_caffe.BlobPro"
      "to\"!\n\020PermuteParameter\022\r\n\005order\030\001 \003(\r\"\235\001"
      "\n\026NormalizeBBoxParameter\022\034\n\016across_spati"
      "al\030\001 \001(\010:\004true\0223\n\014scale_filler\030\002 \001(\0132\035.o"
      "pencv_caffe.FillerParameter\022\034\n\016channel_s"
      "hared\030\003 \001(\010:\004true\022\022\n\003eps\030\004 \001(\002:\0051e-10\"\346\002"
      "\n\021PriorBoxParameter\022\020\n\010min_size\030\001 \001(\002\022\020\n"
      "\010max_size\030\002 \001(\002\022\024\n\014aspect_ratio\030\003 \003(\002\022\022\n"
      "\004flip\030\004 \001(\010:\004true\022\022\n\004clip\030\005 \001(\010:\004true\022\020\n"
      "\010variance\030\006 \003(\002\022\020\n\010img_size\030\007 \001(\r\022\r\n\005img"
      "_h\030\010 \001(\r\022\r\n\005img_w\030\t \001(\r\022\014\n\004step\030\n \001(\002\022\016\n"
      "\006step_h\030\013 \001(\002\022\016\n\006step_w\030\014 \001(\002\022\023\n\006offset\030"
      "\r \001(\002:\0030.5\022\020\n\010offset_h\030\016 \003(\002\022\020\n\010offset_w"
      "\030\017 \003(\002\022\r\n\005width\030\020 \003(\002\022\016\n\006height\030\021 \003(\002\"\'\n"
      "\010CodeType\022\n\n\006CORNER\020\001\022\017\n\013CENTER_SIZE\020\002\"\261"
      "\003\n\030DetectionOutputParameter\022\023\n\013num_class"
      "es\030\001 \001(\r\022\034\n\016share_location\030\002 \001(\010:\004true\022\036"
      "\n\023background_label_id\030\003 \001(\005:\0010\022\?\n\tnms_pa"
      "ram\030\004 \001(\0132,.opencv_caffe.NonMaximumSuppr"
      "essionParameter\022<\n\021save_output_param\030\005 \001"
      "(\0132!.opencv_caffe.SaveOutputParameter\022C\n"
      "\tcode_type\030\006 \001(\0162(.opencv_caffe.PriorBox"
      "Parameter.CodeType:\006CORNER\022)\n\032variance_e"
      "ncoded_in_target\030\010 \001(\010:\005false\022\026\n\nkeep_to"
      "p_k\030\007 \001(\005:\002-1\022\034\n\024confidence_threshold\030\t "
      "\001(\002\022\035\n\017normalized_bbox\030\n \001(\010:\004true\"\201\001\n\005D"
      "atum\022\020\n\010channels\030\001 \001(\005\022\016\n\006height\030\002 \001(\005\022\r"
      "\n\005width\030\003 \001(\005\022\014\n\004data\030\004 \001(\014\022\r\n\005label\030\005 \001"
      "(\005\022\022\n\nfloat_data\030\006 \003(\002\022\026\n\007encoded\030\007 \001(\010:"
      "\005false\"\221\002\n\017FillerParameter\022\026\n\004type\030\001 \001(\t"
      ":\010constant\022\020\n\005value\030\002 \001(\002:\0010\022\016\n\003min\030\003 \001("
      "\002:\0010\022\016\n\003max\030\004 \001(\002:\0011\022\017\n\004mean\030\005 \001(\002:\0010\022\016\n"
      "\003std\030\006 \001(\002:\0011\022\022\n\006sparse\030\007 \001(\005:\002-1\022I\n\rvar"
      "iance_norm\030\010 \001(\0162*.opencv_caffe.FillerPa"
      "rameter.VarianceNorm:\006FAN_IN\"4\n\014Variance"
      "Norm\022\n\n\006FAN_IN\020\000\022\013\n\007FAN_OUT\020\001\022\013\n\007AVERAGE"
      "\020\002\"\252\002\n\014NetParameter\022\014\n\004name\030\001 \001(\t\022\r\n\005inp"
      "ut\030\003 \003(\t\022,\n\013input_shape\030\010 \003(\0132\027.opencv_c"
      "affe.BlobShape\022\021\n\tinput_dim\030\004 \003(\005\022\035\n\016for"
      "ce_backward\030\005 \001(\010:\005false\022%\n\005state\030\006 \001(\0132"
      "\026.opencv_caffe.NetState\022\031\n\ndebug_info\030\007 "
      "\001(\010:\005false\022+\n\005layer\030d \003(\0132\034.opencv_caffe"
      ".LayerParameter\022.\n\006layers\030\002 \003(\0132\036.opencv"
      "_caffe.V1LayerParameter\"\332\n\n\017SolverParame"
      "ter\022\013\n\003net\030\030 \001(\t\022-\n\tnet_param\030\031 \001(\0132\032.op"
      "encv_caffe.NetParameter\022\021\n\ttrain_net\030\001 \001"
      "(\t\022\020\n\010test_net\030\002 \003(\t\0223\n\017train_net_param\030"
      "\025 \001(\0132\032.opencv_caffe.NetParameter\0222\n\016tes"
      "t_net_param\030\026 \003(\0132\032.opencv_caffe.NetPara"
      "meter\022+\n\013train_state\030\032 \001(\0132\026.opencv_caff"
      "e.NetState\022*\n\ntest_state\030\033 \003(\0132\026.opencv_"
      "caffe.NetState\022\021\n\ttest_iter\030\003 \003(\005\022\030\n\rtes"
      "t_interval\030\004 \001(\005:\0010\022 \n\021test_compute_loss"
      "\030\023 \001(\010:\005false\022!\n\023test_initialization\030  \001"
      "(\010:\004true\022\017\n\007base_lr\030\005 \001(\002\022\017\n\007display\030\006 \001"
      "(\005\022\027\n\014average_loss\030! \001(\005:\0011\022\020\n\010max_iter\030"
      "\007 \001(\005\022\024\n\titer_size\030$ \001(\005:\0011\022\021\n\tlr_policy"
      "\030\010 \001(\t\022\r\n\005gamma\030\t \001(\002\022\r\n\005power\030\n \001(\002\022\020\n\010"
      "momentum\030\013 \001(\002\022\024\n\014weight_decay\030\014 \001(\002\022\037\n\023"
      "regularization_type\030\035 \001(\t:\002L2\022\020\n\010stepsiz"
      "e\030\r \001(\005\022\021\n\tstepvalue\030\" \003(\005\022\032\n\016clip_gradi"
      "ents\030# \001(\002:\002-1\022\023\n\010snapshot\030\016 \001(\005:\0010\022\027\n\017s"
      "napshot_prefix\030\017 \001(\t\022\034\n\rsnapshot_diff\030\020 "
      "\001(\010:\005false\022R\n\017snapshot_format\030% \001(\0162,.op"
      "encv_caffe.SolverParameter.SnapshotForma"
      "t:\013BINARYPROTO\022B\n\013solver_mode\030\021 \001(\0162(.op"
      "encv_caffe.SolverParameter.SolverMode:\003G"
      "PU\022\024\n\tdevice_id\030\022 \001(\005:\0010\022\027\n\013random_seed\030"
      "\024 \001(\003:\002-1\022\021\n\004type\030( \001(\t:\003SGD\022\024\n\005delta\030\037 "
      "\001(\002:\0051e-08\022\030\n\tmomentum2\030\' \001(\002:\0050.999\022\027\n\t"
      "rms_decay\030& \001(\002:\0040.99\022\031\n\ndebug_info\030\027 \001("
      "\010:\005false\022\"\n\024snapshot_after_train\030\034 \001(\010:\004"
      "true\022B\n\013solver_type\030\036 \001(\0162(.opencv_caffe"
      ".SolverParameter.SolverType:\003SGD\"+\n\016Snap"
      "shotFormat\022\010\n\004HDF5\020\000\022\017\n\013BINARYPROTO\020\001\"\036\n"
      "\nSolverMode\022\007\n\003CPU\020\000\022\007\n\003GPU\020\001\"U\n\nSolverT"
      "ype\022\007\n\003SGD\020\000\022\014\n\010NESTEROV\020\001\022\013\n\007ADAGRAD\020\002\022"
      "\013\n\007RMSPROP\020\003\022\014\n\010ADADELTA\020\004\022\010\n\004ADAM\020\005\"s\n\013"
      "SolverState\022\014\n\004iter\030\001 \001(\005\022\023\n\013learned_net"
      "\030\002 \001(\t\022(\n\007history\030\003 \003(\0132\027.opencv_caffe.B"
      "lobProto\022\027\n\014current_step\030\004 \001(\005:\0010\"U\n\010Net"
      "State\022(\n\005phase\030\001 \001(\0162\023.opencv_caffe.Phas"
      "e:\004TEST\022\020\n\005level\030\002 \001(\005:\0010\022\r\n\005stage\030\003 \003(\t"
      "\"z\n\014NetStateRule\022\"\n\005phase\030\001 \001(\0162\023.opencv"
      "_caffe.Phase\022\021\n\tmin_level\030\002 \001(\005\022\021\n\tmax_l"
      "evel\030\003 \001(\005\022\r\n\005stage\030\004 \003(\t\022\021\n\tnot_stage\030\005"
      " \003(\t\"\252\001\n\tParamSpec\022\014\n\004name\030\001 \001(\t\0228\n\nshar"
      "e_mode\030\002 \001(\0162$.opencv_caffe.ParamSpec.Di"
      "mCheckMode\022\022\n\007lr_mult\030\003 \001(\002:\0011\022\025\n\ndecay_"
      "mult\030\004 \001(\002:\0011\"*\n\014DimCheckMode\022\n\n\006STRICT\020"
      "\000\022\016\n\nPERMISSIVE\020\001\"\243\032\n\016LayerParameter\022\014\n\004"
      "name\030\001 \001(\t\022\014\n\004type\030\002 \001(\t\022\016\n\006bottom\030\003 \003(\t"
      "\022\013\n\003top\030\004 \003(\t\022\"\n\005phase\030\n \001(\0162\023.opencv_ca"
      "ffe.Phase\022\023\n\013loss_weight\030\005 \003(\002\022&\n\005param\030"
      "\006 \003(\0132\027.opencv_caffe.ParamSpec\022&\n\005blobs\030"
      "\007 \003(\0132\027.opencv_caffe.BlobProto\022\026\n\016propag"
      "ate_down\030\013 \003(\010\022+\n\007include\030\010 \003(\0132\032.opencv"
      "_caffe.NetStateRule\022+\n\007exclude\030\t \003(\0132\032.o"
      "pencv_caffe.NetStateRule\022>\n\017transform_pa"
      "ram\030d \001(\0132%.opencv_caffe.TransformationP"
      "arameter\022/\n\nloss_param\030e \001(\0132\033.opencv_ca"
      "ffe.LossParameter\0227\n\016accuracy_param\030f \001("
      "\0132\037.opencv_caffe.AccuracyParameter\0223\n\014ar"
      "gmax_param\030g \001(\0132\035.opencv_caffe.ArgMaxPa"
      "rameter\022;\n\020batch_norm_param\030\213\001 \001(\0132 .ope"
      "ncv_caffe.BatchNormParameter\0220\n\nbias_par"
      "am\030\215\001 \001(\0132\033.opencv_caffe.BiasParameter\0223"
      "\n\014concat_param\030h \001(\0132\035.opencv_caffe.Conc"
      "atParameter\022F\n\026contrastive_loss_param\030i "
      "\001(\0132&.opencv_caffe.ContrastiveLossParame"
      "ter\022=\n\021convolution_param\030j \001(\0132\".opencv_"
      "caffe.ConvolutionParameter\0220\n\ncrop_param"
      "\030\220\001 \001(\0132\033.opencv_caffe.CropParameter\022/\n\n"
      "data_param\030k \001(\0132\033.opencv_caffe.DataPara"
      "meter\022G\n\026detection_output_param\030\223\001 \001(\0132&"
      ".opencv_caffe.DetectionOutputParameter\0225"
      "\n\rdropout_param\030l \001(\0132\036.opencv_caffe.Dro"
      "poutParameter\022:\n\020dummy_data_param\030m \001(\0132"
      " .opencv_caffe.DummyDataParameter\0225\n\relt"
      "wise_param\030n \001(\0132\036.opencv_caffe.EltwiseP"
      "arameter\022.\n\telu_param\030\214\001 \001(\0132\032.opencv_ca"
      "ffe.ELUParameter\0222\n\013embed_param\030\211\001 \001(\0132\034"
      ".opencv_caffe.EmbedParameter\022-\n\texp_para"
      "m\030o \001(\0132\032.opencv_caffe.ExpParameter\0226\n\rf"
      "latten_param\030\207\001 \001(\0132\036.opencv_caffe.Flatt"
      "enParameter\0228\n\017hdf5_data_param\030p \001(\0132\037.o"
      "pencv_caffe.HDF5DataParameter\022<\n\021hdf5_ou"
      "tput_param\030q \001(\0132!.opencv_caffe.HDF5Outp"
      "utParameter\022:\n\020hinge_loss_param\030r \001(\0132 ."
      "opencv_caffe.HingeLossParameter\022:\n\020image"
      "_data_param\030s \001(\0132 .opencv_caffe.ImageDa"
      "taParameter\022@\n\023infogain_loss_param\030t \001(\013"
      "2#.opencv_caffe.InfogainLossParameter\022@\n"
      "\023inner_product_param\030u \001(\0132#.opencv_caff"
      "e.InnerProductParameter\0222\n\013input_param\030\217"
      "\001 \001(\0132\034.opencv_caffe.InputParameter\022.\n\tl"
      "og_param\030\206\001 \001(\0132\032.opencv_caffe.LogParame"
      "ter\022-\n\tlrn_param\030v \001(\0132\032.opencv_caffe.LR"
      "NParameter\022<\n\021memory_data_param\030w \001(\0132!."
      "opencv_caffe.MemoryDataParameter\022-\n\tmvn_"
      "param\030x \001(\0132\032.opencv_caffe.MVNParameter\022"
      "9\n\nnorm_param\030\225\001 \001(\0132$.opencv_caffe.Norm"
      "alizeBBoxParameter\0226\n\rpermute_param\030\224\001 \001"
      "(\0132\036.opencv_caffe.PermuteParameter\022:\n\017pa"
      "rameter_param\030\221\001 \001(\0132 .opencv_caffe.Para"
      "meterParameter\0225\n\rpooling_param\030y \001(\0132\036."
      "opencv_caffe.PoolingParameter\0221\n\013power_p"
      "aram\030z \001(\0132\034.opencv_caffe.PowerParameter"
      "\0222\n\013prelu_param\030\203\001 \001(\0132\034.opencv_caffe.PR"
      "eLUParameter\0229\n\017prior_box_param\030\226\001 \001(\0132\037"
      ".opencv_caffe.PriorBoxParameter\0228\n\016propo"
      "sal_param\030\311\001 \001(\0132\037.opencv_caffe.Proposal"
      "Parameter\022A\n\023psroi_pooling_param\030\222N \001(\0132"
      "#.opencv_caffe.PSROIPoolingParameter\0224\n\014"
      "python_param\030\202\001 \001(\0132\035.opencv_caffe.Pytho"
      "nParameter\022:\n\017recurrent_param\030\222\001 \001(\0132 .o"
      "pencv_caffe.RecurrentParameter\022:\n\017reduct"
      "ion_param\030\210\001 \001(\0132 .opencv_caffe.Reductio"
      "nParameter\022/\n\nrelu_param\030{ \001(\0132\033.opencv_"
      "caffe.ReLUParameter\0226\n\rreshape_param\030\205\001 "
      "\001(\0132\036.opencv_caffe.ReshapeParameter\022\?\n\021r"
      "oi_pooling_param\030\327\307\370\003 \001(\0132!.opencv_caffe"
      ".ROIPoolingParameter\0222\n\013scale_param\030\216\001 \001"
      "(\0132\034.opencv_caffe.ScaleParameter\0225\n\rsigm"
      "oid_param\030| \001(\0132\036.opencv_caffe.SigmoidPa"
      "rameter\0225\n\rsoftmax_param\030} \001(\0132\036.opencv_"
      "caffe.SoftmaxParameter\022.\n\tspp_param\030\204\001 \001"
      "(\0132\032.opencv_caffe.SPPParameter\0221\n\013slice_"
      "param\030~ \001(\0132\034.opencv_caffe.SliceParamete"
      "r\022/\n\ntanh_param\030\177 \001(\0132\033.opencv_caffe.Tan"
      "HParameter\022:\n\017threshold_param\030\200\001 \001(\0132 .o"
      "pencv_caffe.ThresholdParameter\0220\n\ntile_p"
      "aram\030\212\001 \001(\0132\033.opencv_caffe.TileParameter"
      "\022=\n\021window_data_param\030\201\001 \001(\0132!.opencv_ca"
      "ffe.WindowDataParameter\"\266\001\n\027Transformati"
      "onParameter\022\020\n\005scale\030\001 \001(\002:\0011\022\025\n\006mirror\030"
      "\002 \001(\010:\005false\022\024\n\tcrop_size\030\003 \001(\r:\0010\022\021\n\tme"
      "an_file\030\004 \001(\t\022\022\n\nmean_value\030\005 \003(\002\022\032\n\013for"
      "ce_color\030\006 \001(\010:\005false\022\031\n\nforce_gray\030\007 \001("
      "\010:\005false\"\311\001\n\rLossParameter\022\024\n\014ignore_lab"
      "el\030\001 \001(\005\022K\n\rnormalization\030\003 \001(\0162-.opencv"
      "_caffe.LossParameter.NormalizationMode:\005"
      "VALID\022\021\n\tnormalize\030\002 \001(\010\"B\n\021Normalizatio"
      "nMode\022\010\n\004FULL\020\000\022\t\n\005VALID\020\001\022\016\n\nBATCH_SIZE"
      "\020\002\022\010\n\004NONE\020\003\"L\n\021AccuracyParameter\022\020\n\005top"
      "_k\030\001 \001(\r:\0011\022\017\n\004axis\030\002 \001(\005:\0011\022\024\n\014ignore_l"
      "abel\030\003 \001(\005\"M\n\017ArgMaxParameter\022\032\n\013out_max"
      "_val\030\001 \001(\010:\005false\022\020\n\005top_k\030\002 \001(\r:\0011\022\014\n\004a"
      "xis\030\003 \001(\005\"9\n\017ConcatParameter\022\017\n\004axis\030\002 \001"
      "(\005:\0011\022\025\n\nconcat_dim\030\001 \001(\r:\0011\"\205\001\n\022BatchNo"
      "rmParameter\022\030\n\020use_global_stats\030\001 \001(\010\022&\n"
      "\027moving_average_fraction\030\002 \001(\002:\0050.999\022\022\n"
      "\003eps\030\003 \001(\002:\0051e-05\022\031\n\nscale_bias\030\007 \001(\010:\005f"
      "alse\"d\n\rBiasParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\023"
      "\n\010num_axes\030\002 \001(\005:\0011\022-\n\006filler\030\003 \001(\0132\035.op"
      "encv_caffe.FillerParameter\"L\n\030Contrastiv"
      "eLossParameter\022\021\n\006margin\030\001 \001(\002:\0011\022\035\n\016leg"
      "acy_version\030\002 \001(\010:\005false\"\221\004\n\024Convolution"
      "Parameter\022\022\n\nnum_output\030\001 \001(\r\022\027\n\tbias_te"
      "rm\030\002 \001(\010:\004true\022\013\n\003pad\030\003 \003(\r\022\023\n\013kernel_si"
      "ze\030\004 \003(\r\022\016\n\006stride\030\006 \003(\r\022\020\n\010dilation\030\022 \003"
      "(\r\022\020\n\005pad_h\030\t \001(\r:\0010\022\020\n\005pad_w\030\n \001(\r:\0010\022\020"
      "\n\010kernel_h\030\013 \001(\r\022\020\n\010kernel_w\030\014 \001(\r\022\020\n\010st"
      "ride_h\030\r \001(\r\022\020\n\010stride_w\030\016 \001(\r\022\020\n\005group\030"
      "\005 \001(\r:\0011\0224\n\rweight_filler\030\007 \001(\0132\035.opencv"
      "_caffe.FillerParameter\0222\n\013bias_filler\030\010 "
      "\001(\0132\035.opencv_caffe.FillerParameter\022B\n\006en"
      "gine\030\017 \001(\0162).opencv_caffe.ConvolutionPar"
      "ameter.Engine:\007DEFAULT\022\017\n\004axis\030\020 \001(\005:\0011\022"
      "\036\n\017force_nd_im2col\030\021 \001(\010:\005false\"+\n\006Engin"
      "e\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"0\n\r"
      "CropParameter\022\017\n\004axis\030\001 \001(\005:\0012\022\016\n\006offset"
      "\030\002 \003(\r\"\253\002\n\rDataParameter\022\016\n\006source\030\001 \001(\t"
      "\022\022\n\nbatch_size\030\004 \001(\r\022\024\n\trand_skip\030\007 \001(\r:"
      "\0010\0228\n\007backend\030\010 \001(\0162\036.opencv_caffe.DataP"
      "arameter.DB:\007LEVELDB\022\020\n\005scale\030\002 \001(\002:\0011\022\021"
      "\n\tmean_file\030\003 \001(\t\022\024\n\tcrop_size\030\005 \001(\r:\0010\022"
      "\025\n\006mirror\030\006 \001(\010:\005false\022\"\n\023force_encoded_"
      "color\030\t \001(\010:\005false\022\023\n\010prefetch\030\n \001(\r:\0014\""
      "\033\n\002DB\022\013\n\007LEVELDB\020\000\022\010\n\004LMDB\020\001\"[\n\036NonMaxim"
      "umSuppressionParameter\022\032\n\rnms_threshold\030"
      "\001 \001(\002:\0030.3\022\r\n\005top_k\030\002 \001(\005\022\016\n\003eta\030\003 \001(\002:\001"
      "1\"\252\001\n\023SaveOutputParameter\022\030\n\020output_dire"
      "ctory\030\001 \001(\t\022\032\n\022output_name_prefix\030\002 \001(\t\022"
      "\025\n\routput_format\030\003 \001(\t\022\026\n\016label_map_file"
      "\030\004 \001(\t\022\026\n\016name_size_file\030\005 \001(\t\022\026\n\016num_te"
      "st_image\030\006 \001(\r\"I\n\020DropoutParameter\022\032\n\rdr"
      "opout_ratio\030\001 \001(\002:\0030.5\022\031\n\013scale_train\030\002 "
      "\001(\010:\004true\"\256\001\n\022DummyDataParameter\0222\n\013data"
      "_filler\030\001 \003(\0132\035.opencv_caffe.FillerParam"
      "eter\022&\n\005shape\030\006 \003(\0132\027.opencv_caffe.BlobS"
      "hape\022\013\n\003num\030\002 \003(\r\022\020\n\010channels\030\003 \003(\r\022\016\n\006h"
      "eight\030\004 \003(\r\022\r\n\005width\030\005 \003(\r\"\254\001\n\020EltwisePa"
      "rameter\022@\n\toperation\030\001 \001(\0162(.opencv_caff"
      "e.EltwiseParameter.EltwiseOp:\003SUM\022\r\n\005coe"
      "ff\030\002 \003(\002\022\036\n\020stable_prod_grad\030\003 \001(\010:\004true"
      "\"\'\n\tEltwiseOp\022\010\n\004PROD\020\000\022\007\n\003SUM\020\001\022\007\n\003MAX\020"
      "\002\" \n\014ELUParameter\022\020\n\005alpha\030\001 \001(\002:\0011\"\272\001\n\016"
      "EmbedParameter\022\022\n\nnum_output\030\001 \001(\r\022\021\n\tin"
      "put_dim\030\002 \001(\r\022\027\n\tbias_term\030\003 \001(\010:\004true\0224"
      "\n\rweight_filler\030\004 \001(\0132\035.opencv_caffe.Fil"
      "lerParameter\0222\n\013bias_filler\030\005 \001(\0132\035.open"
      "cv_caffe.FillerParameter\"D\n\014ExpParameter"
      "\022\020\n\004base\030\001 \001(\002:\002-1\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005"
      "shift\030\003 \001(\002:\0010\"9\n\020FlattenParameter\022\017\n\004ax"
      "is\030\001 \001(\005:\0011\022\024\n\010end_axis\030\002 \001(\005:\002-1\"O\n\021HDF"
      "5DataParameter\022\016\n\006source\030\001 \001(\t\022\022\n\nbatch_"
      "size\030\002 \001(\r\022\026\n\007shuffle\030\003 \001(\010:\005false\"(\n\023HD"
      "F5OutputParameter\022\021\n\tfile_name\030\001 \001(\t\"e\n\022"
      "HingeLossParameter\0227\n\004norm\030\001 \001(\0162%.openc"
      "v_caffe.HingeLossParameter.Norm:\002L1\"\026\n\004N"
      "orm\022\006\n\002L1\020\001\022\006\n\002L2\020\002\"\227\002\n\022ImageDataParamet"
      "er\022\016\n\006source\030\001 \001(\t\022\025\n\nbatch_size\030\004 \001(\r:\001"
      "1\022\024\n\trand_skip\030\007 \001(\r:\0010\022\026\n\007shuffle\030\010 \001(\010"
      ":\005false\022\025\n\nnew_height\030\t \001(\r:\0010\022\024\n\tnew_wi"
      "dth\030\n \001(\r:\0010\022\026\n\010is_color\030\013 \001(\010:\004true\022\020\n\005"
      "scale\030\002 \001(\002:\0011\022\021\n\tmean_file\030\003 \001(\t\022\024\n\tcro"
      "p_size\030\005 \001(\r:\0010\022\025\n\006mirror\030\006 \001(\010:\005false\022\025"
      "\n\013root_folder\030\014 \001(\t:\000\"\'\n\025InfogainLossPar"
      "ameter\022\016\n\006source\030\001 \001(\t\"\331\001\n\025InnerProductP"
      "arameter\022\022\n\nnum_output\030\001 \001(\r\022\027\n\tbias_ter"
      "m\030\002 \001(\010:\004true\0224\n\rweight_filler\030\003 \001(\0132\035.o"
      "pencv_caffe.FillerParameter\0222\n\013bias_fill"
      "er\030\004 \001(\0132\035.opencv_caffe.FillerParameter\022"
      "\017\n\004axis\030\005 \001(\005:\0011\022\030\n\ttranspose\030\006 \001(\010:\005fal"
      "se\"8\n\016InputParameter\022&\n\005shape\030\001 \003(\0132\027.op"
      "encv_caffe.BlobShape\"D\n\014LogParameter\022\020\n\004"
      "base\030\001 \001(\002:\002-1\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005shif"
      "t\030\003 \001(\002:\0010\"\306\002\n\014LRNParameter\022\025\n\nlocal_siz"
      "e\030\001 \001(\r:\0015\022\020\n\005alpha\030\002 \001(\002:\0011\022\022\n\004beta\030\003 \001"
      "(\002:\0040.75\022K\n\013norm_region\030\004 \001(\0162%.opencv_c"
      "affe.LRNParameter.NormRegion:\017ACROSS_CHA"
      "NNELS\022\014\n\001k\030\005 \001(\002:\0011\022:\n\006engine\030\006 \001(\0162!.op"
      "encv_caffe.LRNParameter.Engine:\007DEFAULT\""
      "5\n\nNormRegion\022\023\n\017ACROSS_CHANNELS\020\000\022\022\n\016WI"
      "THIN_CHANNEL\020\001\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n"
      "\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"Z\n\023MemoryDataParamet"
      "er\022\022\n\nbatch_size\030\001 \001(\r\022\020\n\010channels\030\002 \001(\r"
      "\022\016\n\006height\030\003 \001(\r\022\r\n\005width\030\004 \001(\r\"d\n\014MVNPa"
      "rameter\022 \n\022normalize_variance\030\001 \001(\010:\004tru"
      "e\022\036\n\017across_channels\030\002 \001(\010:\005false\022\022\n\003eps"
      "\030\003 \001(\002:\0051e-09\"<\n\022ParameterParameter\022&\n\005s"
      "hape\030\001 \001(\0132\027.opencv_caffe.BlobShape\"\311\003\n\020"
      "PoolingParameter\022<\n\004pool\030\001 \001(\0162).opencv_"
      "caffe.PoolingParameter.PoolMethod:\003MAX\022\016"
      "\n\003pad\030\004 \001(\r:\0010\022\020\n\005pad_h\030\t \001(\r:\0010\022\020\n\005pad_"
      "w\030\n \001(\r:\0010\022\023\n\013kernel_size\030\002 \001(\r\022\020\n\010kerne"
      "l_h\030\005 \001(\r\022\020\n\010kernel_w\030\006 \001(\r\022\021\n\006stride\030\003 "
      "\001(\r:\0011\022\020\n\010stride_h\030\007 \001(\r\022\020\n\010stride_w\030\010 \001"
      "(\r\022>\n\006engine\030\013 \001(\0162%.opencv_caffe.Poolin"
      "gParameter.Engine:\007DEFAULT\022\035\n\016global_poo"
      "ling\030\014 \001(\010:\005false\022\027\n\tceil_mode\030\r \001(\010:\004tr"
      "ue\".\n\nPoolMethod\022\007\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n\nST"
      "OCHASTIC\020\002\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAF"
      "FE\020\001\022\t\n\005CUDNN\020\002\"F\n\016PowerParameter\022\020\n\005pow"
      "er\030\001 \001(\002:\0011\022\020\n\005scale\030\002 \001(\002:\0011\022\020\n\005shift\030\003"
      " \001(\002:\0010\"g\n\017PythonParameter\022\016\n\006module\030\001 \001"
      "(\t\022\r\n\005layer\030\002 \001(\t\022\023\n\tparam_str\030\003 \001(\t:\000\022 "
      "\n\021share_in_parallel\030\004 \001(\010:\005false\"\316\001\n\022Rec"
      "urrentParameter\022\025\n\nnum_output\030\001 \001(\r:\0010\0224"
      "\n\rweight_filler\030\002 \001(\0132\035.opencv_caffe.Fil"
      "lerParameter\0222\n\013bias_filler\030\003 \001(\0132\035.open"
      "cv_caffe.FillerParameter\022\031\n\ndebug_info\030\004"
      " \001(\010:\005false\022\034\n\rexpose_hidden\030\005 \001(\010:\005fals"
      "e\"\264\001\n\022ReductionParameter\022D\n\toperation\030\001 "
      "\001(\0162,.opencv_caffe.ReductionParameter.Re"
      "ductionOp:\003SUM\022\017\n\004axis\030\002 \001(\005:\0010\022\020\n\005coeff"
      "\030\003 \001(\002:\0011\"5\n\013ReductionOp\022\007\n\003SUM\020\001\022\010\n\004ASU"
      "M\020\002\022\t\n\005SUMSQ\020\003\022\010\n\004MEAN\020\004\"\224\001\n\rReLUParamet"
      "er\022\031\n\016negative_slope\030\001 \001(\002:\0010\022;\n\006engine\030"
      "\002 \001(\0162\".opencv_caffe.ReLUParameter.Engin"
      "e:\007DEFAULT\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAF"
      "FE\020\001\022\t\n\005CUDNN\020\002\"a\n\020ReshapeParameter\022&\n\005s"
      "hape\030\001 \001(\0132\027.opencv_caffe.BlobShape\022\017\n\004a"
      "xis\030\002 \001(\005:\0010\022\024\n\010num_axes\030\003 \001(\005:\002-1\"\263\001\n\016S"
      "caleParameter\022\017\n\004axis\030\001 \001(\005:\0011\022\023\n\010num_ax"
      "es\030\002 \001(\005:\0011\022-\n\006filler\030\003 \001(\0132\035.opencv_caf"
      "fe.FillerParameter\022\030\n\tbias_term\030\004 \001(\010:\005f"
      "alse\0222\n\013bias_filler\030\005 \001(\0132\035.opencv_caffe"
      ".FillerParameter\"\177\n\020SigmoidParameter\022>\n\006"
      "engine\030\001 \001(\0162%.opencv_caffe.SigmoidParam"
      "eter.Engine:\007DEFAULT\"+\n\006Engine\022\013\n\007DEFAUL"
      "T\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN\020\002\"L\n\016SliceParame"
      "ter\022\017\n\004axis\030\003 \001(\005:\0011\022\023\n\013slice_point\030\002 \003("
      "\r\022\024\n\tslice_dim\030\001 \001(\r:\0011\"\220\001\n\020SoftmaxParam"
      "eter\022>\n\006engine\030\001 \001(\0162%.opencv_caffe.Soft"
      "maxParameter.Engine:\007DEFAULT\022\017\n\004axis\030\002 \001"
      "(\005:\0011\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022"
      "\t\n\005CUDNN\020\002\"y\n\rTanHParameter\022;\n\006engine\030\001 "
      "\001(\0162\".opencv_caffe.TanHParameter.Engine:"
      "\007DEFAULT\"+\n\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE"
      "\020\001\022\t\n\005CUDNN\020\002\"/\n\rTileParameter\022\017\n\004axis\030\001"
      " \001(\005:\0011\022\r\n\005tiles\030\002 \001(\005\"*\n\022ThresholdParam"
      "eter\022\024\n\tthreshold\030\001 \001(\002:\0010\"\301\002\n\023WindowDat"
      "aParameter\022\016\n\006source\030\001 \001(\t\022\020\n\005scale\030\002 \001("
      "\002:\0011\022\021\n\tmean_file\030\003 \001(\t\022\022\n\nbatch_size\030\004 "
      "\001(\r\022\024\n\tcrop_size\030\005 \001(\r:\0010\022\025\n\006mirror\030\006 \001("
      "\010:\005false\022\031\n\014fg_threshold\030\007 \001(\002:\0030.5\022\031\n\014b"
      "g_threshold\030\010 \001(\002:\0030.5\022\031\n\013fg_fraction\030\t "
      "\001(\002:\0040.25\022\026\n\013context_pad\030\n \001(\r:\0010\022\027\n\tcro"
      "p_mode\030\013 \001(\t:\004warp\022\033\n\014cache_images\030\014 \001(\010"
      ":\005false\022\025\n\013root_folder\030\r \001(\t:\000\"\371\001\n\014SPPPa"
      "rameter\022\026\n\016pyramid_height\030\001 \001(\r\0228\n\004pool\030"
      "\002 \001(\0162%.opencv_caffe.SPPParameter.PoolMe"
      "thod:\003MAX\022:\n\006engine\030\006 \001(\0162!.opencv_caffe"
      ".SPPParameter.Engine:\007DEFAULT\".\n\nPoolMet"
      "hod\022\007\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHASTIC\020\002\"+\n"
      "\006Engine\022\013\n\007DEFAULT\020\000\022\t\n\005CAFFE\020\001\022\t\n\005CUDNN"
      "\020\002\"\334\025\n\020V1LayerParameter\022\016\n\006bottom\030\002 \003(\t\022"
      "\013\n\003top\030\003 \003(\t\022\014\n\004name\030\004 \001(\t\022+\n\007include\030  "
      "\003(\0132\032.opencv_caffe.NetStateRule\022+\n\007exclu"
      "de\030! \003(\0132\032.opencv_caffe.NetStateRule\0226\n\004"
      "type\030\005 \001(\0162(.opencv_caffe.V1LayerParamet"
      "er.LayerType\022&\n\005blobs\030\006 \003(\0132\027.opencv_caf"
      "fe.BlobProto\022\016\n\005param\030\351\007 \003(\t\022E\n\017blob_sha"
      "re_mode\030\352\007 \003(\0162+.opencv_caffe.V1LayerPar"
      "ameter.DimCheckMode\022\020\n\010blobs_lr\030\007 \003(\002\022\024\n"
      "\014weight_decay\030\010 \003(\002\022\023\n\013loss_weight\030# \003(\002"
      "\0227\n\016accuracy_param\030\033 \001(\0132\037.opencv_caffe."
      "AccuracyParameter\0223\n\014argmax_param\030\027 \001(\0132"
      "\035.opencv_caffe.ArgMaxParameter\0223\n\014concat"
      "_param\030\t \001(\0132\035.opencv_caffe.ConcatParame"
      "ter\022F\n\026contrastive_loss_param\030( \001(\0132&.op"
      "encv_caffe.ContrastiveLossParameter\022=\n\021c"
      "onvolution_param\030\n \001(\0132\".opencv_caffe.Co"
      "nvolutionParameter\022/\n\ndata_param\030\013 \001(\0132\033"
      ".opencv_caffe.DataParameter\0225\n\rdropout_p"
      "aram\030\014 \001(\0132\036.opencv_caffe.DropoutParamet"
      "er\022:\n\020dummy_data_param\030\032 \001(\0132 .opencv_ca"
      "ffe.DummyDataParameter\0225\n\reltwise_param\030"
      "\030 \001(\0132\036.opencv_caffe.EltwiseParameter\022-\n"
      "\texp_param\030) \001(\0132\032.opencv_caffe.ExpParam"
      "eter\0228\n\017hdf5_data_param\030\r \001(\0132\037.opencv_c"
      "affe.HDF5DataParameter\022<\n\021hdf5_output_pa"
      "ram\030\016 \001(\0132!.opencv_caffe.HDF5OutputParam"
      "eter\022:\n\020hinge_loss_param\030\035 \001(\0132 .opencv_"
      "caffe.HingeLossParameter\022:\n\020image_data_p"
      "aram\030\017 \001(\0132 .opencv_caffe.ImageDataParam"
      "eter\022@\n\023infogain_loss_param\030\020 \001(\0132#.open"
      "cv_caffe.InfogainLossParameter\022@\n\023inner_"
      "product_param\030\021 \001(\0132#.opencv_caffe.Inner"
      "ProductParameter\022-\n\tlrn_param\030\022 \001(\0132\032.op"
      "encv_caffe.LRNParameter\022<\n\021memory_data_p"
      "aram\030\026 \001(\0132!.opencv_caffe.MemoryDataPara"
      "meter\022-\n\tmvn_param\030\" \001(\0132\032.opencv_caffe."
      "MVNParameter\0225\n\rpooling_param\030\023 \001(\0132\036.op"
      "encv_caffe.PoolingParameter\0221\n\013power_par"
      "am\030\025 \001(\0132\034.opencv_caffe.PowerParameter\022/"
      "\n\nrelu_param\030\036 \001(\0132\033.opencv_caffe.ReLUPa"
      "rameter\0225\n\rsigmoid_param\030& \001(\0132\036.opencv_"
      "caffe.SigmoidParameter\0225\n\rsoftmax_param\030"
      "\' \001(\0132\036.opencv_caffe.SoftmaxParameter\0221\n"
      "\013slice_param\030\037 \001(\0132\034.opencv_caffe.SliceP"
      "arameter\022/\n\ntanh_param\030% \001(\0132\033.opencv_ca"
      "ffe.TanHParameter\0229\n\017threshold_param\030\031 \001"
      "(\0132 .opencv_caffe.ThresholdParameter\022<\n\021"
      "window_data_param\030\024 \001(\0132!.opencv_caffe.W"
      "indowDataParameter\022>\n\017transform_param\030$ "
      "\001(\0132%.opencv_caffe.TransformationParamet"
      "er\022/\n\nloss_param\030* \001(\0132\033.opencv_caffe.Lo"
      "ssParameter\022-\n\005layer\030\001 \001(\0132\036.opencv_caff"
      "e.V0LayerParameter\"\330\004\n\tLayerType\022\010\n\004NONE"
      "\020\000\022\n\n\006ABSVAL\020#\022\014\n\010ACCURACY\020\001\022\n\n\006ARGMAX\020\036"
      "\022\010\n\004BNLL\020\002\022\n\n\006CONCAT\020\003\022\024\n\020CONTRASTIVE_LO"
      "SS\020%\022\017\n\013CONVOLUTION\020\004\022\010\n\004DATA\020\005\022\021\n\rDECON"
      "VOLUTION\020\'\022\013\n\007DROPOUT\020\006\022\016\n\nDUMMY_DATA\020 \022"
      "\022\n\016EUCLIDEAN_LOSS\020\007\022\013\n\007ELTWISE\020\031\022\007\n\003EXP\020"
      "&\022\013\n\007FLATTEN\020\010\022\r\n\tHDF5_DATA\020\t\022\017\n\013HDF5_OU"
      "TPUT\020\n\022\016\n\nHINGE_LOSS\020\034\022\n\n\006IM2COL\020\013\022\016\n\nIM"
      "AGE_DATA\020\014\022\021\n\rINFOGAIN_LOSS\020\r\022\021\n\rINNER_P"
      "RODUCT\020\016\022\007\n\003LRN\020\017\022\017\n\013MEMORY_DATA\020\035\022\035\n\031MU"
      "LTINOMIAL_LOGISTIC_LOSS\020\020\022\007\n\003MVN\020\"\022\013\n\007PO"
      "OLING\020\021\022\t\n\005POWER\020\032\022\010\n\004RELU\020\022\022\013\n\007SIGMOID\020"
      "\023\022\036\n\032SIGMOID_CROSS_ENTROPY_LOSS\020\033\022\013\n\007SIL"
      "ENCE\020$\022\013\n\007SOFTMAX\020\024\022\020\n\014SOFTMAX_LOSS\020\025\022\t\n"
      "\005SPLIT\020\026\022\t\n\005SLICE\020!\022\010\n\004TANH\020\027\022\017\n\013WINDOW_"
      "DATA\020\030\022\r\n\tTHRESHOLD\020\037\"*\n\014DimCheckMode\022\n\n"
      "\006STRICT\020\000\022\016\n\nPERMISSIVE\020\001\"\240\010\n\020V0LayerPar"
      "ameter\022\014\n\004name\030\001 \001(\t\022\014\n\004type\030\002 \001(\t\022\022\n\nnu"
      "m_output\030\003 \001(\r\022\026\n\010biasterm\030\004 \001(\010:\004true\0224"
      "\n\rweight_filler\030\005 \001(\0132\035.opencv_caffe.Fil"
      "lerParameter\0222\n\013bias_filler\030\006 \001(\0132\035.open"
      "cv_caffe.FillerParameter\022\016\n\003pad\030\007 \001(\r:\0010"
      "\022\022\n\nkernelsize\030\010 \001(\r\022\020\n\005group\030\t \001(\r:\0011\022\021"
      "\n\006stride\030\n \001(\r:\0011\022<\n\004pool\030\013 \001(\0162).opencv"
      "_caffe.V0LayerParameter.PoolMethod:\003MAX\022"
      "\032\n\rdropout_ratio\030\014 \001(\002:\0030.5\022\025\n\nlocal_siz"
      "e\030\r \001(\r:\0015\022\020\n\005alpha\030\016 \001(\002:\0011\022\022\n\004beta\030\017 \001"
      "(\002:\0040.75\022\014\n\001k\030\026 \001(\002:\0011\022\016\n\006source\030\020 \001(\t\022\020"
      "\n\005scale\030\021 \001(\002:\0011\022\020\n\010meanfile\030\022 \001(\t\022\021\n\tba"
      "tchsize\030\023 \001(\r\022\023\n\010cropsize\030\024 \001(\r:\0010\022\025\n\006mi"
      "rror\030\025 \001(\010:\005false\022&\n\005blobs\0302 \003(\0132\027.openc"
      "v_caffe.BlobProto\022\020\n\010blobs_lr\0303 \003(\002\022\024\n\014w"
      "eight_decay\0304 \003(\002\022\024\n\trand_skip\0305 \001(\r:\0010\022"
      "\035\n\020det_fg_threshold\0306 \001(\002:\0030.5\022\035\n\020det_bg"
      "_threshold\0307 \001(\002:\0030.5\022\035\n\017det_fg_fraction"
      "\0308 \001(\002:\0040.25\022\032\n\017det_context_pad\030: \001(\r:\0010"
      "\022\033\n\rdet_crop_mode\030; \001(\t:\004warp\022\022\n\007new_num"
      "\030< \001(\005:\0010\022\027\n\014new_channels\030= \001(\005:\0010\022\025\n\nne"
      "w_height\030> \001(\005:\0010\022\024\n\tnew_width\030\? \001(\005:\0010\022"
      "\035\n\016shuffle_images\030@ \001(\010:\005false\022\025\n\nconcat"
      "_dim\030A \001(\r:\0011\022=\n\021hdf5_output_param\030\351\007 \001("
      "\0132!.opencv_caffe.HDF5OutputParameter\".\n\n"
      "PoolMethod\022\007\n\003MAX\020\000\022\007\n\003AVE\020\001\022\016\n\nSTOCHAST"
      "IC\020\002\"^\n\016PReLUParameter\022-\n\006filler\030\001 \001(\0132\035"
      ".opencv_caffe.FillerParameter\022\035\n\016channel"
      "_shared\030\002 \001(\010:\005false\"\207\001\n\016NormalizedBBox\022"
      "\014\n\004xmin\030\001 \001(\002\022\014\n\004ymin\030\002 \001(\002\022\014\n\004xmax\030\003 \001("
      "\002\022\014\n\004ymax\030\004 \001(\002\022\r\n\005label\030\005 \001(\005\022\021\n\tdiffic"
      "ult\030\006 \001(\010\022\r\n\005score\030\007 \001(\002\022\014\n\004size\030\010 \001(\002\"Y"
      "\n\023ROIPoolingParameter\022\023\n\010pooled_h\030\001 \001(\r:"
      "\0010\022\023\n\010pooled_w\030\002 \001(\r:\0010\022\030\n\rspatial_scale"
      "\030\003 \001(\002:\0011\"\310\001\n\021ProposalParameter\022\027\n\013feat_"
      "stride\030\001 \001(\r:\00216\022\025\n\tbase_size\030\002 \001(\r:\00216\022"
      "\024\n\010min_size\030\003 \001(\r:\00216\022\r\n\005ratio\030\004 \003(\002\022\r\n\005"
      "scale\030\005 \003(\002\022\032\n\014pre_nms_topn\030\006 \001(\r:\0046000\022"
      "\032\n\rpost_nms_topn\030\007 \001(\r:\003300\022\027\n\nnms_thres"
      "h\030\010 \001(\002:\0030.7\"V\n\025PSROIPoolingParameter\022\025\n"
      "\rspatial_scale\030\001 \002(\002\022\022\n\noutput_dim\030\002 \002(\005"
      "\022\022\n\ngroup_size\030\003 \002(\005*=\n\004Type\022\n\n\006DOUBLE\020\000"
      "\022\t\n\005FLOAT\020\001\022\013\n\007FLOAT16\020\002\022\007\n\003INT\020\003\022\010\n\004UIN"
      "T\020\004*\034\n\005Phase\022\t\n\005TRAIN\020\000\022\010\n\004TEST\020\001"
  };
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      descriptor, 18833);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "opencv-caffe.proto", &protobuf_RegisterTypes);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at dynamic initialization time.
struct StaticDescriptorInitializer {
  StaticDescriptorInitializer() {
    AddDescriptors();
  }
} static_descriptor_initializer;
}  // namespace protobuf_opencv_2dcaffe_2eproto
namespace opencv_caffe {
const ::google::protobuf::EnumDescriptor* PriorBoxParameter_CodeType_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[0];
}
bool PriorBoxParameter_CodeType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const PriorBoxParameter_CodeType PriorBoxParameter::CORNER;
const PriorBoxParameter_CodeType PriorBoxParameter::CENTER_SIZE;
const PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MIN;
const PriorBoxParameter_CodeType PriorBoxParameter::CodeType_MAX;
const int PriorBoxParameter::CodeType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* FillerParameter_VarianceNorm_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[1];
}
bool FillerParameter_VarianceNorm_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const FillerParameter_VarianceNorm FillerParameter::FAN_IN;
const FillerParameter_VarianceNorm FillerParameter::FAN_OUT;
const FillerParameter_VarianceNorm FillerParameter::AVERAGE;
const FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MIN;
const FillerParameter_VarianceNorm FillerParameter::VarianceNorm_MAX;
const int FillerParameter::VarianceNorm_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SolverParameter_SnapshotFormat_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[2];
}
bool SolverParameter_SnapshotFormat_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SolverParameter_SnapshotFormat SolverParameter::HDF5;
const SolverParameter_SnapshotFormat SolverParameter::BINARYPROTO;
const SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MIN;
const SolverParameter_SnapshotFormat SolverParameter::SnapshotFormat_MAX;
const int SolverParameter::SnapshotFormat_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SolverParameter_SolverMode_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[3];
}
bool SolverParameter_SolverMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SolverParameter_SolverMode SolverParameter::CPU;
const SolverParameter_SolverMode SolverParameter::GPU;
const SolverParameter_SolverMode SolverParameter::SolverMode_MIN;
const SolverParameter_SolverMode SolverParameter::SolverMode_MAX;
const int SolverParameter::SolverMode_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SolverParameter_SolverType_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[4];
}
bool SolverParameter_SolverType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SolverParameter_SolverType SolverParameter::SGD;
const SolverParameter_SolverType SolverParameter::NESTEROV;
const SolverParameter_SolverType SolverParameter::ADAGRAD;
const SolverParameter_SolverType SolverParameter::RMSPROP;
const SolverParameter_SolverType SolverParameter::ADADELTA;
const SolverParameter_SolverType SolverParameter::ADAM;
const SolverParameter_SolverType SolverParameter::SolverType_MIN;
const SolverParameter_SolverType SolverParameter::SolverType_MAX;
const int SolverParameter::SolverType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* ParamSpec_DimCheckMode_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[5];
}
bool ParamSpec_DimCheckMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ParamSpec_DimCheckMode ParamSpec::STRICT;
const ParamSpec_DimCheckMode ParamSpec::PERMISSIVE;
const ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MIN;
const ParamSpec_DimCheckMode ParamSpec::DimCheckMode_MAX;
const int ParamSpec::DimCheckMode_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* LossParameter_NormalizationMode_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[6];
}
bool LossParameter_NormalizationMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const LossParameter_NormalizationMode LossParameter::FULL;
const LossParameter_NormalizationMode LossParameter::VALID;
const LossParameter_NormalizationMode LossParameter::BATCH_SIZE;
const LossParameter_NormalizationMode LossParameter::NONE;
const LossParameter_NormalizationMode LossParameter::NormalizationMode_MIN;
const LossParameter_NormalizationMode LossParameter::NormalizationMode_MAX;
const int LossParameter::NormalizationMode_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* ConvolutionParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[7];
}
bool ConvolutionParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ConvolutionParameter_Engine ConvolutionParameter::DEFAULT;
const ConvolutionParameter_Engine ConvolutionParameter::CAFFE;
const ConvolutionParameter_Engine ConvolutionParameter::CUDNN;
const ConvolutionParameter_Engine ConvolutionParameter::Engine_MIN;
const ConvolutionParameter_Engine ConvolutionParameter::Engine_MAX;
const int ConvolutionParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* DataParameter_DB_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[8];
}
bool DataParameter_DB_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const DataParameter_DB DataParameter::LEVELDB;
const DataParameter_DB DataParameter::LMDB;
const DataParameter_DB DataParameter::DB_MIN;
const DataParameter_DB DataParameter::DB_MAX;
const int DataParameter::DB_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[9];
}
bool EltwiseParameter_EltwiseOp_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const EltwiseParameter_EltwiseOp EltwiseParameter::PROD;
const EltwiseParameter_EltwiseOp EltwiseParameter::SUM;
const EltwiseParameter_EltwiseOp EltwiseParameter::MAX;
const EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MIN;
const EltwiseParameter_EltwiseOp EltwiseParameter::EltwiseOp_MAX;
const int EltwiseParameter::EltwiseOp_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* HingeLossParameter_Norm_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[10];
}
bool HingeLossParameter_Norm_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const HingeLossParameter_Norm HingeLossParameter::L1;
const HingeLossParameter_Norm HingeLossParameter::L2;
const HingeLossParameter_Norm HingeLossParameter::Norm_MIN;
const HingeLossParameter_Norm HingeLossParameter::Norm_MAX;
const int HingeLossParameter::Norm_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* LRNParameter_NormRegion_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[11];
}
bool LRNParameter_NormRegion_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const LRNParameter_NormRegion LRNParameter::ACROSS_CHANNELS;
const LRNParameter_NormRegion LRNParameter::WITHIN_CHANNEL;
const LRNParameter_NormRegion LRNParameter::NormRegion_MIN;
const LRNParameter_NormRegion LRNParameter::NormRegion_MAX;
const int LRNParameter::NormRegion_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* LRNParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[12];
}
bool LRNParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const LRNParameter_Engine LRNParameter::DEFAULT;
const LRNParameter_Engine LRNParameter::CAFFE;
const LRNParameter_Engine LRNParameter::CUDNN;
const LRNParameter_Engine LRNParameter::Engine_MIN;
const LRNParameter_Engine LRNParameter::Engine_MAX;
const int LRNParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* PoolingParameter_PoolMethod_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[13];
}
bool PoolingParameter_PoolMethod_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const PoolingParameter_PoolMethod PoolingParameter::MAX;
const PoolingParameter_PoolMethod PoolingParameter::AVE;
const PoolingParameter_PoolMethod PoolingParameter::STOCHASTIC;
const PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MIN;
const PoolingParameter_PoolMethod PoolingParameter::PoolMethod_MAX;
const int PoolingParameter::PoolMethod_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* PoolingParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[14];
}
bool PoolingParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const PoolingParameter_Engine PoolingParameter::DEFAULT;
const PoolingParameter_Engine PoolingParameter::CAFFE;
const PoolingParameter_Engine PoolingParameter::CUDNN;
const PoolingParameter_Engine PoolingParameter::Engine_MIN;
const PoolingParameter_Engine PoolingParameter::Engine_MAX;
const int PoolingParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* ReductionParameter_ReductionOp_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[15];
}
bool ReductionParameter_ReductionOp_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ReductionParameter_ReductionOp ReductionParameter::SUM;
const ReductionParameter_ReductionOp ReductionParameter::ASUM;
const ReductionParameter_ReductionOp ReductionParameter::SUMSQ;
const ReductionParameter_ReductionOp ReductionParameter::MEAN;
const ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MIN;
const ReductionParameter_ReductionOp ReductionParameter::ReductionOp_MAX;
const int ReductionParameter::ReductionOp_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* ReLUParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[16];
}
bool ReLUParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ReLUParameter_Engine ReLUParameter::DEFAULT;
const ReLUParameter_Engine ReLUParameter::CAFFE;
const ReLUParameter_Engine ReLUParameter::CUDNN;
const ReLUParameter_Engine ReLUParameter::Engine_MIN;
const ReLUParameter_Engine ReLUParameter::Engine_MAX;
const int ReLUParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SigmoidParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[17];
}
bool SigmoidParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SigmoidParameter_Engine SigmoidParameter::DEFAULT;
const SigmoidParameter_Engine SigmoidParameter::CAFFE;
const SigmoidParameter_Engine SigmoidParameter::CUDNN;
const SigmoidParameter_Engine SigmoidParameter::Engine_MIN;
const SigmoidParameter_Engine SigmoidParameter::Engine_MAX;
const int SigmoidParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SoftmaxParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[18];
}
bool SoftmaxParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SoftmaxParameter_Engine SoftmaxParameter::DEFAULT;
const SoftmaxParameter_Engine SoftmaxParameter::CAFFE;
const SoftmaxParameter_Engine SoftmaxParameter::CUDNN;
const SoftmaxParameter_Engine SoftmaxParameter::Engine_MIN;
const SoftmaxParameter_Engine SoftmaxParameter::Engine_MAX;
const int SoftmaxParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* TanHParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[19];
}
bool TanHParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const TanHParameter_Engine TanHParameter::DEFAULT;
const TanHParameter_Engine TanHParameter::CAFFE;
const TanHParameter_Engine TanHParameter::CUDNN;
const TanHParameter_Engine TanHParameter::Engine_MIN;
const TanHParameter_Engine TanHParameter::Engine_MAX;
const int TanHParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SPPParameter_PoolMethod_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[20];
}
bool SPPParameter_PoolMethod_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SPPParameter_PoolMethod SPPParameter::MAX;
const SPPParameter_PoolMethod SPPParameter::AVE;
const SPPParameter_PoolMethod SPPParameter::STOCHASTIC;
const SPPParameter_PoolMethod SPPParameter::PoolMethod_MIN;
const SPPParameter_PoolMethod SPPParameter::PoolMethod_MAX;
const int SPPParameter::PoolMethod_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SPPParameter_Engine_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[21];
}
bool SPPParameter_Engine_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SPPParameter_Engine SPPParameter::DEFAULT;
const SPPParameter_Engine SPPParameter::CAFFE;
const SPPParameter_Engine SPPParameter::CUDNN;
const SPPParameter_Engine SPPParameter::Engine_MIN;
const SPPParameter_Engine SPPParameter::Engine_MAX;
const int SPPParameter::Engine_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* V1LayerParameter_LayerType_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[22];
}
bool V1LayerParameter_LayerType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const V1LayerParameter_LayerType V1LayerParameter::NONE;
const V1LayerParameter_LayerType V1LayerParameter::ABSVAL;
const V1LayerParameter_LayerType V1LayerParameter::ACCURACY;
const V1LayerParameter_LayerType V1LayerParameter::ARGMAX;
const V1LayerParameter_LayerType V1LayerParameter::BNLL;
const V1LayerParameter_LayerType V1LayerParameter::CONCAT;
const V1LayerParameter_LayerType V1LayerParameter::CONTRASTIVE_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::CONVOLUTION;
const V1LayerParameter_LayerType V1LayerParameter::DATA;
const V1LayerParameter_LayerType V1LayerParameter::DECONVOLUTION;
const V1LayerParameter_LayerType V1LayerParameter::DROPOUT;
const V1LayerParameter_LayerType V1LayerParameter::DUMMY_DATA;
const V1LayerParameter_LayerType V1LayerParameter::EUCLIDEAN_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::ELTWISE;
const V1LayerParameter_LayerType V1LayerParameter::EXP;
const V1LayerParameter_LayerType V1LayerParameter::FLATTEN;
const V1LayerParameter_LayerType V1LayerParameter::HDF5_DATA;
const V1LayerParameter_LayerType V1LayerParameter::HDF5_OUTPUT;
const V1LayerParameter_LayerType V1LayerParameter::HINGE_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::IM2COL;
const V1LayerParameter_LayerType V1LayerParameter::IMAGE_DATA;
const V1LayerParameter_LayerType V1LayerParameter::INFOGAIN_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::INNER_PRODUCT;
const V1LayerParameter_LayerType V1LayerParameter::LRN;
const V1LayerParameter_LayerType V1LayerParameter::MEMORY_DATA;
const V1LayerParameter_LayerType V1LayerParameter::MULTINOMIAL_LOGISTIC_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::MVN;
const V1LayerParameter_LayerType V1LayerParameter::POOLING;
const V1LayerParameter_LayerType V1LayerParameter::POWER;
const V1LayerParameter_LayerType V1LayerParameter::RELU;
const V1LayerParameter_LayerType V1LayerParameter::SIGMOID;
const V1LayerParameter_LayerType V1LayerParameter::SIGMOID_CROSS_ENTROPY_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::SILENCE;
const V1LayerParameter_LayerType V1LayerParameter::SOFTMAX;
const V1LayerParameter_LayerType V1LayerParameter::SOFTMAX_LOSS;
const V1LayerParameter_LayerType V1LayerParameter::SPLIT;
const V1LayerParameter_LayerType V1LayerParameter::SLICE;
const V1LayerParameter_LayerType V1LayerParameter::TANH;
const V1LayerParameter_LayerType V1LayerParameter::WINDOW_DATA;
const V1LayerParameter_LayerType V1LayerParameter::THRESHOLD;
const V1LayerParameter_LayerType V1LayerParameter::LayerType_MIN;
const V1LayerParameter_LayerType V1LayerParameter::LayerType_MAX;
const int V1LayerParameter::LayerType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* V1LayerParameter_DimCheckMode_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[23];
}
bool V1LayerParameter_DimCheckMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const V1LayerParameter_DimCheckMode V1LayerParameter::STRICT;
const V1LayerParameter_DimCheckMode V1LayerParameter::PERMISSIVE;
const V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MIN;
const V1LayerParameter_DimCheckMode V1LayerParameter::DimCheckMode_MAX;
const int V1LayerParameter::DimCheckMode_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[24];
}
bool V0LayerParameter_PoolMethod_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const V0LayerParameter_PoolMethod V0LayerParameter::MAX;
const V0LayerParameter_PoolMethod V0LayerParameter::AVE;
const V0LayerParameter_PoolMethod V0LayerParameter::STOCHASTIC;
const V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MIN;
const V0LayerParameter_PoolMethod V0LayerParameter::PoolMethod_MAX;
const int V0LayerParameter::PoolMethod_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* Type_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[25];
}
bool Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* Phase_descriptor() {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_opencv_2dcaffe_2eproto::file_level_enum_descriptors[26];
}
bool Phase_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}


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

void BlobShape::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BlobShape::kDimFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BlobShape::BlobShape()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.BlobShape)
}
BlobShape::BlobShape(const BlobShape& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      dim_(from.dim_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobShape)
}

void BlobShape::SharedCtor() {
  _cached_size_ = 0;
}

BlobShape::~BlobShape() {
  // @@protoc_insertion_point(destructor:opencv_caffe.BlobShape)
  SharedDtor();
}

void BlobShape::SharedDtor() {
}

void BlobShape::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BlobShape::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const BlobShape& BlobShape::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobShape();
  return *internal_default_instance();
}

BlobShape* BlobShape::New(::google::protobuf::Arena* arena) const {
  BlobShape* n = new BlobShape;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BlobShape::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobShape)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  dim_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BlobShape::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.BlobShape)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated int64 dim = 1 [packed = true];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_dim())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 1, 10u, input, this->mutable_dim())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.BlobShape)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.BlobShape)
  return false;
#undef DO_
}

void BlobShape::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.BlobShape)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int64 dim = 1 [packed = true];
  if (this->dim_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
        _dim_cached_byte_size_));
  }
  for (int i = 0, n = this->dim_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64NoTag(
      this->dim(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.BlobShape)
}

::google::protobuf::uint8* BlobShape::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobShape)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int64 dim = 1 [packed = true];
  if (this->dim_size() > 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
      1,
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
        static_cast< ::google::protobuf::int32>(
            _dim_cached_byte_size_), target);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt64NoTagToArray(this->dim_, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobShape)
  return target;
}

size_t BlobShape::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobShape)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated int64 dim = 1 [packed = true];
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int64Size(this->dim_);
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
            static_cast< ::google::protobuf::int32>(data_size));
    }
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _dim_cached_byte_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BlobShape::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.BlobShape)
  GOOGLE_DCHECK_NE(&from, this);
  const BlobShape* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const BlobShape>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.BlobShape)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.BlobShape)
    MergeFrom(*source);
  }
}

void BlobShape::MergeFrom(const BlobShape& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobShape)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  dim_.MergeFrom(from.dim_);
}

void BlobShape::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.BlobShape)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BlobShape::CopyFrom(const BlobShape& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobShape)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BlobShape::IsInitialized() const {
  return true;
}

void BlobShape::Swap(BlobShape* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BlobShape::InternalSwap(BlobShape* other) {
  using std::swap;
  dim_.InternalSwap(&other->dim_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata BlobShape::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void BlobProto::InitAsDefaultInstance() {
  ::opencv_caffe::_BlobProto_default_instance_._instance.get_mutable()->shape_ = const_cast< ::opencv_caffe::BlobShape*>(
      ::opencv_caffe::BlobShape::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BlobProto::kShapeFieldNumber;
const int BlobProto::kDataFieldNumber;
const int BlobProto::kDiffFieldNumber;
const int BlobProto::kDoubleDataFieldNumber;
const int BlobProto::kDoubleDiffFieldNumber;
const int BlobProto::kRawDataTypeFieldNumber;
const int BlobProto::kRawDataFieldNumber;
const int BlobProto::kNumFieldNumber;
const int BlobProto::kChannelsFieldNumber;
const int BlobProto::kHeightFieldNumber;
const int BlobProto::kWidthFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BlobProto::BlobProto()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.BlobProto)
}
BlobProto::BlobProto(const BlobProto& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      data_(from.data_),
      diff_(from.diff_),
      double_data_(from.double_data_),
      double_diff_(from.double_diff_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  raw_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_raw_data()) {
    raw_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.raw_data_);
  }
  if (from.has_shape()) {
    shape_ = new ::opencv_caffe::BlobShape(*from.shape_);
  } else {
    shape_ = NULL;
  }
  ::memcpy(&num_, &from.num_,
    static_cast<size_t>(reinterpret_cast<char*>(&raw_data_type_) -
    reinterpret_cast<char*>(&num_)) + sizeof(raw_data_type_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobProto)
}

void BlobProto::SharedCtor() {
  _cached_size_ = 0;
  raw_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&shape_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&raw_data_type_) -
      reinterpret_cast<char*>(&shape_)) + sizeof(raw_data_type_));
}

BlobProto::~BlobProto() {
  // @@protoc_insertion_point(destructor:opencv_caffe.BlobProto)
  SharedDtor();
}

void BlobProto::SharedDtor() {
  raw_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete shape_;
}

void BlobProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BlobProto::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const BlobProto& BlobProto::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProto();
  return *internal_default_instance();
}

BlobProto* BlobProto::New(::google::protobuf::Arena* arena) const {
  BlobProto* n = new BlobProto;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BlobProto::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobProto)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  diff_.Clear();
  double_data_.Clear();
  double_diff_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!raw_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*raw_data_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(shape_ != NULL);
      shape_->Clear();
    }
  }
  if (cached_has_bits & 124u) {
    ::memset(&num_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&raw_data_type_) -
        reinterpret_cast<char*>(&num_)) + sizeof(raw_data_type_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BlobProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.BlobProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 num = 1 [default = 0];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_num();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 channels = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 height = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 width = 4 [default = 0];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float data = 5 [packed = true];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_data())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 42u, input, this->mutable_data())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float diff = 6 [packed = true];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_diff())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(53u /* 53 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 50u, input, this->mutable_diff())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.BlobShape shape = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_shape()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated double double_data = 8 [packed = true];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, this->mutable_double_data())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(65u /* 65 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 1, 66u, input, this->mutable_double_data())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated double double_diff = 9 [packed = true];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, this->mutable_double_diff())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(73u /* 73 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 1, 74u, input, this->mutable_double_diff())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.Type raw_data_type = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::Type_IsValid(value)) {
            set_raw_data_type(static_cast< ::opencv_caffe::Type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                10, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes raw_data = 12 [packed = false];
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_raw_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.BlobProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.BlobProto)
  return false;
#undef DO_
}

void BlobProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.BlobProto)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 num = 1 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->num(), output);
  }

  // optional int32 channels = 2 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->channels(), output);
  }

  // optional int32 height = 3 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->height(), output);
  }

  // optional int32 width = 4 [default = 0];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->width(), output);
  }

  // repeated float data = 5 [packed = true];
  if (this->data_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
        _data_cached_byte_size_));
    ::google::protobuf::internal::WireFormatLite::WriteFloatArray(
      this->data().data(), this->data_size(), output);
  }

  // repeated float diff = 6 [packed = true];
  if (this->diff_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
        _diff_cached_byte_size_));
    ::google::protobuf::internal::WireFormatLite::WriteFloatArray(
      this->diff().data(), this->diff_size(), output);
  }

  // optional .opencv_caffe.BlobShape shape = 7;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, *this->shape_, output);
  }

  // repeated double double_data = 8 [packed = true];
  if (this->double_data_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(8, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
        _double_data_cached_byte_size_));
    ::google::protobuf::internal::WireFormatLite::WriteDoubleArray(
      this->double_data().data(), this->double_data_size(), output);
  }

  // repeated double double_diff = 9 [packed = true];
  if (this->double_diff_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
        _double_diff_cached_byte_size_));
    ::google::protobuf::internal::WireFormatLite::WriteDoubleArray(
      this->double_diff().data(), this->double_diff_size(), output);
  }

  // optional .opencv_caffe.Type raw_data_type = 10;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      10, this->raw_data_type(), output);
  }

  // optional bytes raw_data = 12 [packed = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      12, this->raw_data(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.BlobProto)
}

::google::protobuf::uint8* BlobProto::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobProto)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 num = 1 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->num(), target);
  }

  // optional int32 channels = 2 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->channels(), target);
  }

  // optional int32 height = 3 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->height(), target);
  }

  // optional int32 width = 4 [default = 0];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->width(), target);
  }

  // repeated float data = 5 [packed = true];
  if (this->data_size() > 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
      5,
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
        static_cast< ::google::protobuf::int32>(
            _data_cached_byte_size_), target);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->data_, target);
  }

  // repeated float diff = 6 [packed = true];
  if (this->diff_size() > 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
      6,
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
        static_cast< ::google::protobuf::int32>(
            _diff_cached_byte_size_), target);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->diff_, target);
  }

  // optional .opencv_caffe.BlobShape shape = 7;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        7, *this->shape_, deterministic, target);
  }

  // repeated double double_data = 8 [packed = true];
  if (this->double_data_size() > 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
      8,
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
        static_cast< ::google::protobuf::int32>(
            _double_data_cached_byte_size_), target);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteDoubleNoTagToArray(this->double_data_, target);
  }

  // repeated double double_diff = 9 [packed = true];
  if (this->double_diff_size() > 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
      9,
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
        static_cast< ::google::protobuf::int32>(
            _double_diff_cached_byte_size_), target);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteDoubleNoTagToArray(this->double_diff_, target);
  }

  // optional .opencv_caffe.Type raw_data_type = 10;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      10, this->raw_data_type(), target);
  }

  // optional bytes raw_data = 12 [packed = false];
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        12, this->raw_data(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobProto)
  return target;
}

size_t BlobProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobProto)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated float data = 5 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->data_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
            static_cast< ::google::protobuf::int32>(data_size));
    }
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _data_cached_byte_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  // repeated float diff = 6 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->diff_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
            static_cast< ::google::protobuf::int32>(data_size));
    }
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _diff_cached_byte_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  // repeated double double_data = 8 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->double_data_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
            static_cast< ::google::protobuf::int32>(data_size));
    }
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _double_data_cached_byte_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  // repeated double double_diff = 9 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->double_diff_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
            static_cast< ::google::protobuf::int32>(data_size));
    }
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _double_diff_cached_byte_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 127u) {
    // optional bytes raw_data = 12 [packed = false];
    if (has_raw_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->raw_data());
    }

    // optional .opencv_caffe.BlobShape shape = 7;
    if (has_shape()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->shape_);
    }

    // optional int32 num = 1 [default = 0];
    if (has_num()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->num());
    }

    // optional int32 channels = 2 [default = 0];
    if (has_channels()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->channels());
    }

    // optional int32 height = 3 [default = 0];
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }

    // optional int32 width = 4 [default = 0];
    if (has_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->width());
    }

    // optional .opencv_caffe.Type raw_data_type = 10;
    if (has_raw_data_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->raw_data_type());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BlobProto::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.BlobProto)
  GOOGLE_DCHECK_NE(&from, this);
  const BlobProto* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const BlobProto>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.BlobProto)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.BlobProto)
    MergeFrom(*source);
  }
}

void BlobProto::MergeFrom(const BlobProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobProto)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
  diff_.MergeFrom(from.diff_);
  double_data_.MergeFrom(from.double_data_);
  double_diff_.MergeFrom(from.double_diff_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 127u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_raw_data();
      raw_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.raw_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from.shape());
    }
    if (cached_has_bits & 0x00000004u) {
      num_ = from.num_;
    }
    if (cached_has_bits & 0x00000008u) {
      channels_ = from.channels_;
    }
    if (cached_has_bits & 0x00000010u) {
      height_ = from.height_;
    }
    if (cached_has_bits & 0x00000020u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000040u) {
      raw_data_type_ = from.raw_data_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void BlobProto::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.BlobProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BlobProto::CopyFrom(const BlobProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BlobProto::IsInitialized() const {
  return true;
}

void BlobProto::Swap(BlobProto* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BlobProto::InternalSwap(BlobProto* other) {
  using std::swap;
  data_.InternalSwap(&other->data_);
  diff_.InternalSwap(&other->diff_);
  double_data_.InternalSwap(&other->double_data_);
  double_diff_.InternalSwap(&other->double_diff_);
  raw_data_.Swap(&other->raw_data_);
  swap(shape_, other->shape_);
  swap(num_, other->num_);
  swap(channels_, other->channels_);
  swap(height_, other->height_);
  swap(width_, other->width_);
  swap(raw_data_type_, other->raw_data_type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata BlobProto::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void BlobProtoVector::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BlobProtoVector::kBlobsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BlobProtoVector::BlobProtoVector()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProtoVector();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.BlobProtoVector)
}
BlobProtoVector::BlobProtoVector(const BlobProtoVector& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      blobs_(from.blobs_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.BlobProtoVector)
}

void BlobProtoVector::SharedCtor() {
  _cached_size_ = 0;
}

BlobProtoVector::~BlobProtoVector() {
  // @@protoc_insertion_point(destructor:opencv_caffe.BlobProtoVector)
  SharedDtor();
}

void BlobProtoVector::SharedDtor() {
}

void BlobProtoVector::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BlobProtoVector::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const BlobProtoVector& BlobProtoVector::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBlobProtoVector();
  return *internal_default_instance();
}

BlobProtoVector* BlobProtoVector::New(::google::protobuf::Arena* arena) const {
  BlobProtoVector* n = new BlobProtoVector;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BlobProtoVector::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.BlobProtoVector)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  blobs_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BlobProtoVector::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.BlobProtoVector)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .opencv_caffe.BlobProto blobs = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_blobs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.BlobProtoVector)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.BlobProtoVector)
  return false;
#undef DO_
}

void BlobProtoVector::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.BlobProtoVector)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .opencv_caffe.BlobProto blobs = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->blobs(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.BlobProtoVector)
}

::google::protobuf::uint8* BlobProtoVector::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BlobProtoVector)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .opencv_caffe.BlobProto blobs = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->blobs(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BlobProtoVector)
  return target;
}

size_t BlobProtoVector::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BlobProtoVector)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .opencv_caffe.BlobProto blobs = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->blobs_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->blobs(static_cast<int>(i)));
    }
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BlobProtoVector::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.BlobProtoVector)
  GOOGLE_DCHECK_NE(&from, this);
  const BlobProtoVector* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const BlobProtoVector>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.BlobProtoVector)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.BlobProtoVector)
    MergeFrom(*source);
  }
}

void BlobProtoVector::MergeFrom(const BlobProtoVector& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BlobProtoVector)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  blobs_.MergeFrom(from.blobs_);
}

void BlobProtoVector::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.BlobProtoVector)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BlobProtoVector::CopyFrom(const BlobProtoVector& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BlobProtoVector)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BlobProtoVector::IsInitialized() const {
  return true;
}

void BlobProtoVector::Swap(BlobProtoVector* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BlobProtoVector::InternalSwap(BlobProtoVector* other) {
  using std::swap;
  blobs_.InternalSwap(&other->blobs_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata BlobProtoVector::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PermuteParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PermuteParameter::kOrderFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PermuteParameter::PermuteParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPermuteParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PermuteParameter)
}
PermuteParameter::PermuteParameter(const PermuteParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      order_(from.order_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PermuteParameter)
}

void PermuteParameter::SharedCtor() {
  _cached_size_ = 0;
}

PermuteParameter::~PermuteParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PermuteParameter)
  SharedDtor();
}

void PermuteParameter::SharedDtor() {
}

void PermuteParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PermuteParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PermuteParameter& PermuteParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPermuteParameter();
  return *internal_default_instance();
}

PermuteParameter* PermuteParameter::New(::google::protobuf::Arena* arena) const {
  PermuteParameter* n = new PermuteParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PermuteParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PermuteParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  order_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PermuteParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PermuteParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint32 order = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 8u, input, this->mutable_order())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_order())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PermuteParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PermuteParameter)
  return false;
#undef DO_
}

void PermuteParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PermuteParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated uint32 order = 1;
  for (int i = 0, n = this->order_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      1, this->order(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PermuteParameter)
}

::google::protobuf::uint8* PermuteParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PermuteParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated uint32 order = 1;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(1, this->order_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PermuteParameter)
  return target;
}

size_t PermuteParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PermuteParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated uint32 order = 1;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->order_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->order_size());
    total_size += data_size;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PermuteParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PermuteParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PermuteParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PermuteParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PermuteParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PermuteParameter)
    MergeFrom(*source);
  }
}

void PermuteParameter::MergeFrom(const PermuteParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PermuteParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  order_.MergeFrom(from.order_);
}

void PermuteParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PermuteParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PermuteParameter::CopyFrom(const PermuteParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PermuteParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PermuteParameter::IsInitialized() const {
  return true;
}

void PermuteParameter::Swap(PermuteParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PermuteParameter::InternalSwap(PermuteParameter* other) {
  using std::swap;
  order_.InternalSwap(&other->order_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PermuteParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void NormalizeBBoxParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_NormalizeBBoxParameter_default_instance_._instance.get_mutable()->scale_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NormalizeBBoxParameter::kAcrossSpatialFieldNumber;
const int NormalizeBBoxParameter::kScaleFillerFieldNumber;
const int NormalizeBBoxParameter::kChannelSharedFieldNumber;
const int NormalizeBBoxParameter::kEpsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NormalizeBBoxParameter::NormalizeBBoxParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizeBBoxParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.NormalizeBBoxParameter)
}
NormalizeBBoxParameter::NormalizeBBoxParameter(const NormalizeBBoxParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_scale_filler()) {
    scale_filler_ = new ::opencv_caffe::FillerParameter(*from.scale_filler_);
  } else {
    scale_filler_ = NULL;
  }
  ::memcpy(&across_spatial_, &from.across_spatial_,
    static_cast<size_t>(reinterpret_cast<char*>(&eps_) -
    reinterpret_cast<char*>(&across_spatial_)) + sizeof(eps_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizeBBoxParameter)
}

void NormalizeBBoxParameter::SharedCtor() {
  _cached_size_ = 0;
  scale_filler_ = NULL;
  across_spatial_ = true;
  channel_shared_ = true;
  eps_ = 1e-10f;
}

NormalizeBBoxParameter::~NormalizeBBoxParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.NormalizeBBoxParameter)
  SharedDtor();
}

void NormalizeBBoxParameter::SharedDtor() {
  if (this != internal_default_instance()) delete scale_filler_;
}

void NormalizeBBoxParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NormalizeBBoxParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const NormalizeBBoxParameter& NormalizeBBoxParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizeBBoxParameter();
  return *internal_default_instance();
}

NormalizeBBoxParameter* NormalizeBBoxParameter::New(::google::protobuf::Arena* arena) const {
  NormalizeBBoxParameter* n = new NormalizeBBoxParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NormalizeBBoxParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.NormalizeBBoxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(scale_filler_ != NULL);
      scale_filler_->Clear();
    }
    across_spatial_ = true;
    channel_shared_ = true;
    eps_ = 1e-10f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NormalizeBBoxParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.NormalizeBBoxParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool across_spatial = 1 [default = true];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_across_spatial();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &across_spatial_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter scale_filler = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_scale_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool channel_shared = 3 [default = true];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_channel_shared();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &channel_shared_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float eps = 4 [default = 1e-10];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
          set_has_eps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &eps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.NormalizeBBoxParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.NormalizeBBoxParameter)
  return false;
#undef DO_
}

void NormalizeBBoxParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.NormalizeBBoxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool across_spatial = 1 [default = true];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->across_spatial(), output);
  }

  // optional .opencv_caffe.FillerParameter scale_filler = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->scale_filler_, output);
  }

  // optional bool channel_shared = 3 [default = true];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->channel_shared(), output);
  }

  // optional float eps = 4 [default = 1e-10];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->eps(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.NormalizeBBoxParameter)
}

::google::protobuf::uint8* NormalizeBBoxParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NormalizeBBoxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool across_spatial = 1 [default = true];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->across_spatial(), target);
  }

  // optional .opencv_caffe.FillerParameter scale_filler = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->scale_filler_, deterministic, target);
  }

  // optional bool channel_shared = 3 [default = true];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->channel_shared(), target);
  }

  // optional float eps = 4 [default = 1e-10];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->eps(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NormalizeBBoxParameter)
  return target;
}

size_t NormalizeBBoxParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NormalizeBBoxParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional .opencv_caffe.FillerParameter scale_filler = 2;
    if (has_scale_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->scale_filler_);
    }

    // optional bool across_spatial = 1 [default = true];
    if (has_across_spatial()) {
      total_size += 1 + 1;
    }

    // optional bool channel_shared = 3 [default = true];
    if (has_channel_shared()) {
      total_size += 1 + 1;
    }

    // optional float eps = 4 [default = 1e-10];
    if (has_eps()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NormalizeBBoxParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.NormalizeBBoxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const NormalizeBBoxParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NormalizeBBoxParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.NormalizeBBoxParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.NormalizeBBoxParameter)
    MergeFrom(*source);
  }
}

void NormalizeBBoxParameter::MergeFrom(const NormalizeBBoxParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NormalizeBBoxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_scale_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.scale_filler());
    }
    if (cached_has_bits & 0x00000002u) {
      across_spatial_ = from.across_spatial_;
    }
    if (cached_has_bits & 0x00000004u) {
      channel_shared_ = from.channel_shared_;
    }
    if (cached_has_bits & 0x00000008u) {
      eps_ = from.eps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NormalizeBBoxParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.NormalizeBBoxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NormalizeBBoxParameter::CopyFrom(const NormalizeBBoxParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NormalizeBBoxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NormalizeBBoxParameter::IsInitialized() const {
  return true;
}

void NormalizeBBoxParameter::Swap(NormalizeBBoxParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NormalizeBBoxParameter::InternalSwap(NormalizeBBoxParameter* other) {
  using std::swap;
  swap(scale_filler_, other->scale_filler_);
  swap(across_spatial_, other->across_spatial_);
  swap(channel_shared_, other->channel_shared_);
  swap(eps_, other->eps_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NormalizeBBoxParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PriorBoxParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PriorBoxParameter::kMinSizeFieldNumber;
const int PriorBoxParameter::kMaxSizeFieldNumber;
const int PriorBoxParameter::kAspectRatioFieldNumber;
const int PriorBoxParameter::kFlipFieldNumber;
const int PriorBoxParameter::kClipFieldNumber;
const int PriorBoxParameter::kVarianceFieldNumber;
const int PriorBoxParameter::kImgSizeFieldNumber;
const int PriorBoxParameter::kImgHFieldNumber;
const int PriorBoxParameter::kImgWFieldNumber;
const int PriorBoxParameter::kStepFieldNumber;
const int PriorBoxParameter::kStepHFieldNumber;
const int PriorBoxParameter::kStepWFieldNumber;
const int PriorBoxParameter::kOffsetFieldNumber;
const int PriorBoxParameter::kOffsetHFieldNumber;
const int PriorBoxParameter::kOffsetWFieldNumber;
const int PriorBoxParameter::kWidthFieldNumber;
const int PriorBoxParameter::kHeightFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PriorBoxParameter::PriorBoxParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPriorBoxParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PriorBoxParameter)
}
PriorBoxParameter::PriorBoxParameter(const PriorBoxParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      aspect_ratio_(from.aspect_ratio_),
      variance_(from.variance_),
      offset_h_(from.offset_h_),
      offset_w_(from.offset_w_),
      width_(from.width_),
      height_(from.height_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&min_size_, &from.min_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&offset_) -
    reinterpret_cast<char*>(&min_size_)) + sizeof(offset_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PriorBoxParameter)
}

void PriorBoxParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&min_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&step_w_) -
      reinterpret_cast<char*>(&min_size_)) + sizeof(step_w_));
  flip_ = true;
  clip_ = true;
  offset_ = 0.5f;
}

PriorBoxParameter::~PriorBoxParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PriorBoxParameter)
  SharedDtor();
}

void PriorBoxParameter::SharedDtor() {
}

void PriorBoxParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PriorBoxParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PriorBoxParameter& PriorBoxParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPriorBoxParameter();
  return *internal_default_instance();
}

PriorBoxParameter* PriorBoxParameter::New(::google::protobuf::Arena* arena) const {
  PriorBoxParameter* n = new PriorBoxParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PriorBoxParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PriorBoxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  aspect_ratio_.Clear();
  variance_.Clear();
  offset_h_.Clear();
  offset_w_.Clear();
  width_.Clear();
  height_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    ::memset(&min_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&step_w_) -
        reinterpret_cast<char*>(&min_size_)) + sizeof(step_w_));
  }
  if (cached_has_bits & 1792u) {
    flip_ = true;
    clip_ = true;
    offset_ = 0.5f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PriorBoxParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PriorBoxParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float min_size = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_min_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &min_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float max_size = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_max_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &max_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float aspect_ratio = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 29u, input, this->mutable_aspect_ratio())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_aspect_ratio())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool flip = 4 [default = true];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_flip();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &flip_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool clip = 5 [default = true];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_clip();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &clip_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float variance = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(53u /* 53 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 53u, input, this->mutable_variance())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_variance())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 img_size = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_img_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &img_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 img_h = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          set_has_img_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &img_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 img_w = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_img_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &img_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float step = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(85u /* 85 & 0xFF */)) {
          set_has_step();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &step_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float step_h = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(93u /* 93 & 0xFF */)) {
          set_has_step_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &step_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float step_w = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(101u /* 101 & 0xFF */)) {
          set_has_step_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &step_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float offset = 13 [default = 0.5];
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(109u /* 109 & 0xFF */)) {
          set_has_offset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float offset_h = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(117u /* 117 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 117u, input, this->mutable_offset_h())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(114u /* 114 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_offset_h())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float offset_w = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(125u /* 125 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 125u, input, this->mutable_offset_w())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(122u /* 122 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_offset_w())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float width = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(133u /* 133 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 2, 133u, input, this->mutable_width())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(130u /* 130 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_width())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float height = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(141u /* 141 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 2, 141u, input, this->mutable_height())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(138u /* 138 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_height())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PriorBoxParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PriorBoxParameter)
  return false;
#undef DO_
}

void PriorBoxParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PriorBoxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float min_size = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->min_size(), output);
  }

  // optional float max_size = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->max_size(), output);
  }

  // repeated float aspect_ratio = 3;
  for (int i = 0, n = this->aspect_ratio_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      3, this->aspect_ratio(i), output);
  }

  // optional bool flip = 4 [default = true];
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->flip(), output);
  }

  // optional bool clip = 5 [default = true];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->clip(), output);
  }

  // repeated float variance = 6;
  for (int i = 0, n = this->variance_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      6, this->variance(i), output);
  }

  // optional uint32 img_size = 7;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->img_size(), output);
  }

  // optional uint32 img_h = 8;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->img_h(), output);
  }

  // optional uint32 img_w = 9;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->img_w(), output);
  }

  // optional float step = 10;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->step(), output);
  }

  // optional float step_h = 11;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->step_h(), output);
  }

  // optional float step_w = 12;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->step_w(), output);
  }

  // optional float offset = 13 [default = 0.5];
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->offset(), output);
  }

  // repeated float offset_h = 14;
  for (int i = 0, n = this->offset_h_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      14, this->offset_h(i), output);
  }

  // repeated float offset_w = 15;
  for (int i = 0, n = this->offset_w_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      15, this->offset_w(i), output);
  }

  // repeated float width = 16;
  for (int i = 0, n = this->width_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      16, this->width(i), output);
  }

  // repeated float height = 17;
  for (int i = 0, n = this->height_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      17, this->height(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PriorBoxParameter)
}

::google::protobuf::uint8* PriorBoxParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PriorBoxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float min_size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->min_size(), target);
  }

  // optional float max_size = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->max_size(), target);
  }

  // repeated float aspect_ratio = 3;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(3, this->aspect_ratio_, target);

  // optional bool flip = 4 [default = true];
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->flip(), target);
  }

  // optional bool clip = 5 [default = true];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->clip(), target);
  }

  // repeated float variance = 6;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(6, this->variance_, target);

  // optional uint32 img_size = 7;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->img_size(), target);
  }

  // optional uint32 img_h = 8;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->img_h(), target);
  }

  // optional uint32 img_w = 9;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->img_w(), target);
  }

  // optional float step = 10;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->step(), target);
  }

  // optional float step_h = 11;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->step_h(), target);
  }

  // optional float step_w = 12;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->step_w(), target);
  }

  // optional float offset = 13 [default = 0.5];
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->offset(), target);
  }

  // repeated float offset_h = 14;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(14, this->offset_h_, target);

  // repeated float offset_w = 15;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(15, this->offset_w_, target);

  // repeated float width = 16;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(16, this->width_, target);

  // repeated float height = 17;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(17, this->height_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PriorBoxParameter)
  return target;
}

size_t PriorBoxParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PriorBoxParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated float aspect_ratio = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->aspect_ratio_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->aspect_ratio_size());
    total_size += data_size;
  }

  // repeated float variance = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->variance_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->variance_size());
    total_size += data_size;
  }

  // repeated float offset_h = 14;
  {
    unsigned int count = static_cast<unsigned int>(this->offset_h_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->offset_h_size());
    total_size += data_size;
  }

  // repeated float offset_w = 15;
  {
    unsigned int count = static_cast<unsigned int>(this->offset_w_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->offset_w_size());
    total_size += data_size;
  }

  // repeated float width = 16;
  {
    unsigned int count = static_cast<unsigned int>(this->width_size());
    size_t data_size = 4UL * count;
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->width_size());
    total_size += data_size;
  }

  // repeated float height = 17;
  {
    unsigned int count = static_cast<unsigned int>(this->height_size());
    size_t data_size = 4UL * count;
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->height_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional float min_size = 1;
    if (has_min_size()) {
      total_size += 1 + 4;
    }

    // optional float max_size = 2;
    if (has_max_size()) {
      total_size += 1 + 4;
    }

    // optional uint32 img_size = 7;
    if (has_img_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->img_size());
    }

    // optional uint32 img_h = 8;
    if (has_img_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->img_h());
    }

    // optional uint32 img_w = 9;
    if (has_img_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->img_w());
    }

    // optional float step = 10;
    if (has_step()) {
      total_size += 1 + 4;
    }

    // optional float step_h = 11;
    if (has_step_h()) {
      total_size += 1 + 4;
    }

    // optional float step_w = 12;
    if (has_step_w()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & 1792u) {
    // optional bool flip = 4 [default = true];
    if (has_flip()) {
      total_size += 1 + 1;
    }

    // optional bool clip = 5 [default = true];
    if (has_clip()) {
      total_size += 1 + 1;
    }

    // optional float offset = 13 [default = 0.5];
    if (has_offset()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PriorBoxParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PriorBoxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PriorBoxParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PriorBoxParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PriorBoxParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PriorBoxParameter)
    MergeFrom(*source);
  }
}

void PriorBoxParameter::MergeFrom(const PriorBoxParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PriorBoxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  aspect_ratio_.MergeFrom(from.aspect_ratio_);
  variance_.MergeFrom(from.variance_);
  offset_h_.MergeFrom(from.offset_h_);
  offset_w_.MergeFrom(from.offset_w_);
  width_.MergeFrom(from.width_);
  height_.MergeFrom(from.height_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      min_size_ = from.min_size_;
    }
    if (cached_has_bits & 0x00000002u) {
      max_size_ = from.max_size_;
    }
    if (cached_has_bits & 0x00000004u) {
      img_size_ = from.img_size_;
    }
    if (cached_has_bits & 0x00000008u) {
      img_h_ = from.img_h_;
    }
    if (cached_has_bits & 0x00000010u) {
      img_w_ = from.img_w_;
    }
    if (cached_has_bits & 0x00000020u) {
      step_ = from.step_;
    }
    if (cached_has_bits & 0x00000040u) {
      step_h_ = from.step_h_;
    }
    if (cached_has_bits & 0x00000080u) {
      step_w_ = from.step_w_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 1792u) {
    if (cached_has_bits & 0x00000100u) {
      flip_ = from.flip_;
    }
    if (cached_has_bits & 0x00000200u) {
      clip_ = from.clip_;
    }
    if (cached_has_bits & 0x00000400u) {
      offset_ = from.offset_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PriorBoxParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PriorBoxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PriorBoxParameter::CopyFrom(const PriorBoxParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PriorBoxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PriorBoxParameter::IsInitialized() const {
  return true;
}

void PriorBoxParameter::Swap(PriorBoxParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PriorBoxParameter::InternalSwap(PriorBoxParameter* other) {
  using std::swap;
  aspect_ratio_.InternalSwap(&other->aspect_ratio_);
  variance_.InternalSwap(&other->variance_);
  offset_h_.InternalSwap(&other->offset_h_);
  offset_w_.InternalSwap(&other->offset_w_);
  width_.InternalSwap(&other->width_);
  height_.InternalSwap(&other->height_);
  swap(min_size_, other->min_size_);
  swap(max_size_, other->max_size_);
  swap(img_size_, other->img_size_);
  swap(img_h_, other->img_h_);
  swap(img_w_, other->img_w_);
  swap(step_, other->step_);
  swap(step_h_, other->step_h_);
  swap(step_w_, other->step_w_);
  swap(flip_, other->flip_);
  swap(clip_, other->clip_);
  swap(offset_, other->offset_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PriorBoxParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DetectionOutputParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_DetectionOutputParameter_default_instance_._instance.get_mutable()->nms_param_ = const_cast< ::opencv_caffe::NonMaximumSuppressionParameter*>(
      ::opencv_caffe::NonMaximumSuppressionParameter::internal_default_instance());
  ::opencv_caffe::_DetectionOutputParameter_default_instance_._instance.get_mutable()->save_output_param_ = const_cast< ::opencv_caffe::SaveOutputParameter*>(
      ::opencv_caffe::SaveOutputParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DetectionOutputParameter::kNumClassesFieldNumber;
const int DetectionOutputParameter::kShareLocationFieldNumber;
const int DetectionOutputParameter::kBackgroundLabelIdFieldNumber;
const int DetectionOutputParameter::kNmsParamFieldNumber;
const int DetectionOutputParameter::kSaveOutputParamFieldNumber;
const int DetectionOutputParameter::kCodeTypeFieldNumber;
const int DetectionOutputParameter::kVarianceEncodedInTargetFieldNumber;
const int DetectionOutputParameter::kKeepTopKFieldNumber;
const int DetectionOutputParameter::kConfidenceThresholdFieldNumber;
const int DetectionOutputParameter::kNormalizedBboxFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DetectionOutputParameter::DetectionOutputParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDetectionOutputParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.DetectionOutputParameter)
}
DetectionOutputParameter::DetectionOutputParameter(const DetectionOutputParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_nms_param()) {
    nms_param_ = new ::opencv_caffe::NonMaximumSuppressionParameter(*from.nms_param_);
  } else {
    nms_param_ = NULL;
  }
  if (from.has_save_output_param()) {
    save_output_param_ = new ::opencv_caffe::SaveOutputParameter(*from.save_output_param_);
  } else {
    save_output_param_ = NULL;
  }
  ::memcpy(&num_classes_, &from.num_classes_,
    static_cast<size_t>(reinterpret_cast<char*>(&normalized_bbox_) -
    reinterpret_cast<char*>(&num_classes_)) + sizeof(normalized_bbox_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.DetectionOutputParameter)
}

void DetectionOutputParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&nms_param_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&confidence_threshold_) -
      reinterpret_cast<char*>(&nms_param_)) + sizeof(confidence_threshold_));
  keep_top_k_ = -1;
  code_type_ = 1;
  share_location_ = true;
  normalized_bbox_ = true;
}

DetectionOutputParameter::~DetectionOutputParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.DetectionOutputParameter)
  SharedDtor();
}

void DetectionOutputParameter::SharedDtor() {
  if (this != internal_default_instance()) delete nms_param_;
  if (this != internal_default_instance()) delete save_output_param_;
}

void DetectionOutputParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DetectionOutputParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DetectionOutputParameter& DetectionOutputParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDetectionOutputParameter();
  return *internal_default_instance();
}

DetectionOutputParameter* DetectionOutputParameter::New(::google::protobuf::Arena* arena) const {
  DetectionOutputParameter* n = new DetectionOutputParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DetectionOutputParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.DetectionOutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(nms_param_ != NULL);
      nms_param_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(save_output_param_ != NULL);
      save_output_param_->Clear();
    }
  }
  if (cached_has_bits & 252u) {
    ::memset(&num_classes_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&confidence_threshold_) -
        reinterpret_cast<char*>(&num_classes_)) + sizeof(confidence_threshold_));
    keep_top_k_ = -1;
    code_type_ = 1;
  }
  if (cached_has_bits & 768u) {
    share_location_ = true;
    normalized_bbox_ = true;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DetectionOutputParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.DetectionOutputParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_classes = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_num_classes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_classes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool share_location = 2 [default = true];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_share_location();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &share_location_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 background_label_id = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_background_label_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &background_label_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_nms_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_save_output_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::PriorBoxParameter_CodeType_IsValid(value)) {
            set_code_type(static_cast< ::opencv_caffe::PriorBoxParameter_CodeType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                6, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 keep_top_k = 7 [default = -1];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_keep_top_k();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &keep_top_k_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool variance_encoded_in_target = 8 [default = false];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          set_has_variance_encoded_in_target();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &variance_encoded_in_target_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float confidence_threshold = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(77u /* 77 & 0xFF */)) {
          set_has_confidence_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &confidence_threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool normalized_bbox = 10 [default = true];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_normalized_bbox();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &normalized_bbox_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.DetectionOutputParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.DetectionOutputParameter)
  return false;
#undef DO_
}

void DetectionOutputParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.DetectionOutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_classes = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_classes(), output);
  }

  // optional bool share_location = 2 [default = true];
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->share_location(), output);
  }

  // optional int32 background_label_id = 3 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->background_label_id(), output);
  }

  // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, *this->nms_param_, output);
  }

  // optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->save_output_param_, output);
  }

  // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->code_type(), output);
  }

  // optional int32 keep_top_k = 7 [default = -1];
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->keep_top_k(), output);
  }

  // optional bool variance_encoded_in_target = 8 [default = false];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->variance_encoded_in_target(), output);
  }

  // optional float confidence_threshold = 9;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->confidence_threshold(), output);
  }

  // optional bool normalized_bbox = 10 [default = true];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->normalized_bbox(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.DetectionOutputParameter)
}

::google::protobuf::uint8* DetectionOutputParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DetectionOutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_classes = 1;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_classes(), target);
  }

  // optional bool share_location = 2 [default = true];
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->share_location(), target);
  }

  // optional int32 background_label_id = 3 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->background_label_id(), target);
  }

  // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, *this->nms_param_, deterministic, target);
  }

  // optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, *this->save_output_param_, deterministic, target);
  }

  // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      6, this->code_type(), target);
  }

  // optional int32 keep_top_k = 7 [default = -1];
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->keep_top_k(), target);
  }

  // optional bool variance_encoded_in_target = 8 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->variance_encoded_in_target(), target);
  }

  // optional float confidence_threshold = 9;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->confidence_threshold(), target);
  }

  // optional bool normalized_bbox = 10 [default = true];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->normalized_bbox(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DetectionOutputParameter)
  return target;
}

size_t DetectionOutputParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DetectionOutputParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional .opencv_caffe.NonMaximumSuppressionParameter nms_param = 4;
    if (has_nms_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->nms_param_);
    }

    // optional .opencv_caffe.SaveOutputParameter save_output_param = 5;
    if (has_save_output_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->save_output_param_);
    }

    // optional uint32 num_classes = 1;
    if (has_num_classes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_classes());
    }

    // optional int32 background_label_id = 3 [default = 0];
    if (has_background_label_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->background_label_id());
    }

    // optional bool variance_encoded_in_target = 8 [default = false];
    if (has_variance_encoded_in_target()) {
      total_size += 1 + 1;
    }

    // optional float confidence_threshold = 9;
    if (has_confidence_threshold()) {
      total_size += 1 + 4;
    }

    // optional int32 keep_top_k = 7 [default = -1];
    if (has_keep_top_k()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->keep_top_k());
    }

    // optional .opencv_caffe.PriorBoxParameter.CodeType code_type = 6 [default = CORNER];
    if (has_code_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->code_type());
    }

  }
  if (_has_bits_[8 / 32] & 768u) {
    // optional bool share_location = 2 [default = true];
    if (has_share_location()) {
      total_size += 1 + 1;
    }

    // optional bool normalized_bbox = 10 [default = true];
    if (has_normalized_bbox()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DetectionOutputParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.DetectionOutputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const DetectionOutputParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DetectionOutputParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.DetectionOutputParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.DetectionOutputParameter)
    MergeFrom(*source);
  }
}

void DetectionOutputParameter::MergeFrom(const DetectionOutputParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DetectionOutputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_nms_param()->::opencv_caffe::NonMaximumSuppressionParameter::MergeFrom(from.nms_param());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_save_output_param()->::opencv_caffe::SaveOutputParameter::MergeFrom(from.save_output_param());
    }
    if (cached_has_bits & 0x00000004u) {
      num_classes_ = from.num_classes_;
    }
    if (cached_has_bits & 0x00000008u) {
      background_label_id_ = from.background_label_id_;
    }
    if (cached_has_bits & 0x00000010u) {
      variance_encoded_in_target_ = from.variance_encoded_in_target_;
    }
    if (cached_has_bits & 0x00000020u) {
      confidence_threshold_ = from.confidence_threshold_;
    }
    if (cached_has_bits & 0x00000040u) {
      keep_top_k_ = from.keep_top_k_;
    }
    if (cached_has_bits & 0x00000080u) {
      code_type_ = from.code_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 768u) {
    if (cached_has_bits & 0x00000100u) {
      share_location_ = from.share_location_;
    }
    if (cached_has_bits & 0x00000200u) {
      normalized_bbox_ = from.normalized_bbox_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DetectionOutputParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.DetectionOutputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DetectionOutputParameter::CopyFrom(const DetectionOutputParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DetectionOutputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DetectionOutputParameter::IsInitialized() const {
  return true;
}

void DetectionOutputParameter::Swap(DetectionOutputParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DetectionOutputParameter::InternalSwap(DetectionOutputParameter* other) {
  using std::swap;
  swap(nms_param_, other->nms_param_);
  swap(save_output_param_, other->save_output_param_);
  swap(num_classes_, other->num_classes_);
  swap(background_label_id_, other->background_label_id_);
  swap(variance_encoded_in_target_, other->variance_encoded_in_target_);
  swap(confidence_threshold_, other->confidence_threshold_);
  swap(keep_top_k_, other->keep_top_k_);
  swap(code_type_, other->code_type_);
  swap(share_location_, other->share_location_);
  swap(normalized_bbox_, other->normalized_bbox_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DetectionOutputParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void Datum::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Datum::kChannelsFieldNumber;
const int Datum::kHeightFieldNumber;
const int Datum::kWidthFieldNumber;
const int Datum::kDataFieldNumber;
const int Datum::kLabelFieldNumber;
const int Datum::kFloatDataFieldNumber;
const int Datum::kEncodedFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Datum::Datum()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDatum();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.Datum)
}
Datum::Datum(const Datum& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      float_data_(from.float_data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  ::memcpy(&channels_, &from.channels_,
    static_cast<size_t>(reinterpret_cast<char*>(&encoded_) -
    reinterpret_cast<char*>(&channels_)) + sizeof(encoded_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.Datum)
}

void Datum::SharedCtor() {
  _cached_size_ = 0;
  data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&channels_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&encoded_) -
      reinterpret_cast<char*>(&channels_)) + sizeof(encoded_));
}

Datum::~Datum() {
  // @@protoc_insertion_point(destructor:opencv_caffe.Datum)
  SharedDtor();
}

void Datum::SharedDtor() {
  data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void Datum::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Datum::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const Datum& Datum::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDatum();
  return *internal_default_instance();
}

Datum* Datum::New(::google::protobuf::Arena* arena) const {
  Datum* n = new Datum;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Datum::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.Datum)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  float_data_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*data_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 62u) {
    ::memset(&channels_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&encoded_) -
        reinterpret_cast<char*>(&channels_)) + sizeof(encoded_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Datum::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.Datum)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 channels = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 height = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 width = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes data = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 label = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_label();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &label_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float float_data = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(53u /* 53 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 53u, input, this->mutable_float_data())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_float_data())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool encoded = 7 [default = false];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_encoded();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &encoded_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.Datum)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.Datum)
  return false;
#undef DO_
}

void Datum::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.Datum)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 channels = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->channels(), output);
  }

  // optional int32 height = 2;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->height(), output);
  }

  // optional int32 width = 3;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->width(), output);
  }

  // optional bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->data(), output);
  }

  // optional int32 label = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->label(), output);
  }

  // repeated float float_data = 6;
  for (int i = 0, n = this->float_data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      6, this->float_data(i), output);
  }

  // optional bool encoded = 7 [default = false];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->encoded(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.Datum)
}

::google::protobuf::uint8* Datum::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.Datum)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 channels = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->channels(), target);
  }

  // optional int32 height = 2;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->height(), target);
  }

  // optional int32 width = 3;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->width(), target);
  }

  // optional bytes data = 4;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        4, this->data(), target);
  }

  // optional int32 label = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->label(), target);
  }

  // repeated float float_data = 6;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(6, this->float_data_, target);

  // optional bool encoded = 7 [default = false];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->encoded(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.Datum)
  return target;
}

size_t Datum::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.Datum)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated float float_data = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->float_data_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->float_data_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 63u) {
    // optional bytes data = 4;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->data());
    }

    // optional int32 channels = 1;
    if (has_channels()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->channels());
    }

    // optional int32 height = 2;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }

    // optional int32 width = 3;
    if (has_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->width());
    }

    // optional int32 label = 5;
    if (has_label()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->label());
    }

    // optional bool encoded = 7 [default = false];
    if (has_encoded()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Datum::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.Datum)
  GOOGLE_DCHECK_NE(&from, this);
  const Datum* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const Datum>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.Datum)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.Datum)
    MergeFrom(*source);
  }
}

void Datum::MergeFrom(const Datum& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.Datum)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  float_data_.MergeFrom(from.float_data_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_data();
      data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      channels_ = from.channels_;
    }
    if (cached_has_bits & 0x00000004u) {
      height_ = from.height_;
    }
    if (cached_has_bits & 0x00000008u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000010u) {
      label_ = from.label_;
    }
    if (cached_has_bits & 0x00000020u) {
      encoded_ = from.encoded_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Datum::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.Datum)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Datum::CopyFrom(const Datum& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.Datum)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Datum::IsInitialized() const {
  return true;
}

void Datum::Swap(Datum* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Datum::InternalSwap(Datum* other) {
  using std::swap;
  float_data_.InternalSwap(&other->float_data_);
  data_.Swap(&other->data_);
  swap(channels_, other->channels_);
  swap(height_, other->height_);
  swap(width_, other->width_);
  swap(label_, other->label_);
  swap(encoded_, other->encoded_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata Datum::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void FillerParameter::InitAsDefaultInstance() {
}
::google::protobuf::internal::ExplicitlyConstructed< ::std::string> FillerParameter::_default_type_;
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FillerParameter::kTypeFieldNumber;
const int FillerParameter::kValueFieldNumber;
const int FillerParameter::kMinFieldNumber;
const int FillerParameter::kMaxFieldNumber;
const int FillerParameter::kMeanFieldNumber;
const int FillerParameter::kStdFieldNumber;
const int FillerParameter::kSparseFieldNumber;
const int FillerParameter::kVarianceNormFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FillerParameter::FillerParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.FillerParameter)
}
FillerParameter::FillerParameter(const FillerParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  type_.UnsafeSetDefault(&::opencv_caffe::FillerParameter::_default_type_.get());
  if (from.has_type()) {
    type_.AssignWithDefault(&::opencv_caffe::FillerParameter::_default_type_.get(), from.type_);
  }
  ::memcpy(&value_, &from.value_,
    static_cast<size_t>(reinterpret_cast<char*>(&std_) -
    reinterpret_cast<char*>(&value_)) + sizeof(std_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.FillerParameter)
}

void FillerParameter::SharedCtor() {
  _cached_size_ = 0;
  type_.UnsafeSetDefault(&::opencv_caffe::FillerParameter::_default_type_.get());
  ::memset(&value_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&variance_norm_) -
      reinterpret_cast<char*>(&value_)) + sizeof(variance_norm_));
  sparse_ = -1;
  max_ = 1;
  std_ = 1;
}

FillerParameter::~FillerParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.FillerParameter)
  SharedDtor();
}

void FillerParameter::SharedDtor() {
  type_.DestroyNoArena(&::opencv_caffe::FillerParameter::_default_type_.get());
}

void FillerParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* FillerParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const FillerParameter& FillerParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsFillerParameter();
  return *internal_default_instance();
}

FillerParameter* FillerParameter::New(::google::protobuf::Arena* arena) const {
  FillerParameter* n = new FillerParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FillerParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.FillerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!type_.IsDefault(&::opencv_caffe::FillerParameter::_default_type_.get()));
    (*type_.UnsafeRawStringPointer())->assign(*&::opencv_caffe::FillerParameter::_default_type_.get());
  }
  if (cached_has_bits & 254u) {
    ::memset(&value_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&variance_norm_) -
        reinterpret_cast<char*>(&value_)) + sizeof(variance_norm_));
    sparse_ = -1;
    max_ = 1;
    std_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FillerParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.FillerParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string type = 1 [default = "constant"];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_type()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->type().data(), static_cast<int>(this->type().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.FillerParameter.type");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float value = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_value();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &value_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float min = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_min();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &min_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float max = 4 [default = 1];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
          set_has_max();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &max_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float mean = 5 [default = 0];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          set_has_mean();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &mean_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float std = 6 [default = 1];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(53u /* 53 & 0xFF */)) {
          set_has_std();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &std_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 sparse = 7 [default = -1];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_sparse();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sparse_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::FillerParameter_VarianceNorm_IsValid(value)) {
            set_variance_norm(static_cast< ::opencv_caffe::FillerParameter_VarianceNorm >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                8, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.FillerParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.FillerParameter)
  return false;
#undef DO_
}

void FillerParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.FillerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string type = 1 [default = "constant"];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.FillerParameter.type");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->type(), output);
  }

  // optional float value = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->value(), output);
  }

  // optional float min = 3 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->min(), output);
  }

  // optional float max = 4 [default = 1];
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->max(), output);
  }

  // optional float mean = 5 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->mean(), output);
  }

  // optional float std = 6 [default = 1];
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->std(), output);
  }

  // optional int32 sparse = 7 [default = -1];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->sparse(), output);
  }

  // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->variance_norm(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.FillerParameter)
}

::google::protobuf::uint8* FillerParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.FillerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string type = 1 [default = "constant"];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.FillerParameter.type");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->type(), target);
  }

  // optional float value = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->value(), target);
  }

  // optional float min = 3 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->min(), target);
  }

  // optional float max = 4 [default = 1];
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->max(), target);
  }

  // optional float mean = 5 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->mean(), target);
  }

  // optional float std = 6 [default = 1];
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->std(), target);
  }

  // optional int32 sparse = 7 [default = -1];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->sparse(), target);
  }

  // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->variance_norm(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.FillerParameter)
  return target;
}

size_t FillerParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.FillerParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional string type = 1 [default = "constant"];
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->type());
    }

    // optional float value = 2 [default = 0];
    if (has_value()) {
      total_size += 1 + 4;
    }

    // optional float min = 3 [default = 0];
    if (has_min()) {
      total_size += 1 + 4;
    }

    // optional float mean = 5 [default = 0];
    if (has_mean()) {
      total_size += 1 + 4;
    }

    // optional .opencv_caffe.FillerParameter.VarianceNorm variance_norm = 8 [default = FAN_IN];
    if (has_variance_norm()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->variance_norm());
    }

    // optional int32 sparse = 7 [default = -1];
    if (has_sparse()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->sparse());
    }

    // optional float max = 4 [default = 1];
    if (has_max()) {
      total_size += 1 + 4;
    }

    // optional float std = 6 [default = 1];
    if (has_std()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FillerParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.FillerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const FillerParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const FillerParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.FillerParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.FillerParameter)
    MergeFrom(*source);
  }
}

void FillerParameter::MergeFrom(const FillerParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.FillerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_type();
      type_.AssignWithDefault(&::opencv_caffe::FillerParameter::_default_type_.get(), from.type_);
    }
    if (cached_has_bits & 0x00000002u) {
      value_ = from.value_;
    }
    if (cached_has_bits & 0x00000004u) {
      min_ = from.min_;
    }
    if (cached_has_bits & 0x00000008u) {
      mean_ = from.mean_;
    }
    if (cached_has_bits & 0x00000010u) {
      variance_norm_ = from.variance_norm_;
    }
    if (cached_has_bits & 0x00000020u) {
      sparse_ = from.sparse_;
    }
    if (cached_has_bits & 0x00000040u) {
      max_ = from.max_;
    }
    if (cached_has_bits & 0x00000080u) {
      std_ = from.std_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FillerParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.FillerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void FillerParameter::CopyFrom(const FillerParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.FillerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FillerParameter::IsInitialized() const {
  return true;
}

void FillerParameter::Swap(FillerParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FillerParameter::InternalSwap(FillerParameter* other) {
  using std::swap;
  type_.Swap(&other->type_);
  swap(value_, other->value_);
  swap(min_, other->min_);
  swap(mean_, other->mean_);
  swap(variance_norm_, other->variance_norm_);
  swap(sparse_, other->sparse_);
  swap(max_, other->max_);
  swap(std_, other->std_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata FillerParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void NetParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_NetParameter_default_instance_._instance.get_mutable()->state_ = const_cast< ::opencv_caffe::NetState*>(
      ::opencv_caffe::NetState::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NetParameter::kNameFieldNumber;
const int NetParameter::kInputFieldNumber;
const int NetParameter::kInputShapeFieldNumber;
const int NetParameter::kInputDimFieldNumber;
const int NetParameter::kForceBackwardFieldNumber;
const int NetParameter::kStateFieldNumber;
const int NetParameter::kDebugInfoFieldNumber;
const int NetParameter::kLayerFieldNumber;
const int NetParameter::kLayersFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NetParameter::NetParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.NetParameter)
}
NetParameter::NetParameter(const NetParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      layers_(from.layers_),
      input_(from.input_),
      input_dim_(from.input_dim_),
      input_shape_(from.input_shape_),
      layer_(from.layer_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.has_state()) {
    state_ = new ::opencv_caffe::NetState(*from.state_);
  } else {
    state_ = NULL;
  }
  ::memcpy(&force_backward_, &from.force_backward_,
    static_cast<size_t>(reinterpret_cast<char*>(&debug_info_) -
    reinterpret_cast<char*>(&force_backward_)) + sizeof(debug_info_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetParameter)
}

void NetParameter::SharedCtor() {
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&state_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&debug_info_) -
      reinterpret_cast<char*>(&state_)) + sizeof(debug_info_));
}

NetParameter::~NetParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.NetParameter)
  SharedDtor();
}

void NetParameter::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete state_;
}

void NetParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NetParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const NetParameter& NetParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetParameter();
  return *internal_default_instance();
}

NetParameter* NetParameter::New(::google::protobuf::Arena* arena) const {
  NetParameter* n = new NetParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NetParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.NetParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  layers_.Clear();
  input_.Clear();
  input_dim_.Clear();
  input_shape_.Clear();
  layer_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*name_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(state_ != NULL);
      state_->Clear();
    }
  }
  ::memset(&force_backward_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&debug_info_) -
      reinterpret_cast<char*>(&force_backward_)) + sizeof(debug_info_));
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NetParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.NetParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.NetParameter.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.V1LayerParameter layers = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_layers()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string input = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_input()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->input(this->input_size() - 1).data(),
            static_cast<int>(this->input(this->input_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.NetParameter.input");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated int32 input_dim = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 32u, input, this->mutable_input_dim())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_input_dim())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool force_backward = 5 [default = false];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_force_backward();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &force_backward_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.NetState state = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_state()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool debug_info = 7 [default = false];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_debug_info();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &debug_info_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.BlobShape input_shape = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_input_shape()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.LayerParameter layer = 100;
      case 100: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 802 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_layer()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.NetParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.NetParameter)
  return false;
#undef DO_
}

void NetParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.NetParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetParameter.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // repeated .opencv_caffe.V1LayerParameter layers = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->layers_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->layers(static_cast<int>(i)), output);
  }

  // repeated string input = 3;
  for (int i = 0, n = this->input_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->input(i).data(), static_cast<int>(this->input(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetParameter.input");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->input(i), output);
  }

  // repeated int32 input_dim = 4;
  for (int i = 0, n = this->input_dim_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      4, this->input_dim(i), output);
  }

  // optional bool force_backward = 5 [default = false];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->force_backward(), output);
  }

  // optional .opencv_caffe.NetState state = 6;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, *this->state_, output);
  }

  // optional bool debug_info = 7 [default = false];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->debug_info(), output);
  }

  // repeated .opencv_caffe.BlobShape input_shape = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->input_shape_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, this->input_shape(static_cast<int>(i)), output);
  }

  // repeated .opencv_caffe.LayerParameter layer = 100;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->layer_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      100, this->layer(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.NetParameter)
}

::google::protobuf::uint8* NetParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetParameter.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // repeated .opencv_caffe.V1LayerParameter layers = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->layers_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->layers(static_cast<int>(i)), deterministic, target);
  }

  // repeated string input = 3;
  for (int i = 0, n = this->input_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->input(i).data(), static_cast<int>(this->input(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetParameter.input");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(3, this->input(i), target);
  }

  // repeated int32 input_dim = 4;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteInt32ToArray(4, this->input_dim_, target);

  // optional bool force_backward = 5 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->force_backward(), target);
  }

  // optional .opencv_caffe.NetState state = 6;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, *this->state_, deterministic, target);
  }

  // optional bool debug_info = 7 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->debug_info(), target);
  }

  // repeated .opencv_caffe.BlobShape input_shape = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->input_shape_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, this->input_shape(static_cast<int>(i)), deterministic, target);
  }

  // repeated .opencv_caffe.LayerParameter layer = 100;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->layer_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        100, this->layer(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetParameter)
  return target;
}

size_t NetParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .opencv_caffe.V1LayerParameter layers = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->layers_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->layers(static_cast<int>(i)));
    }
  }

  // repeated string input = 3;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->input_size());
  for (int i = 0, n = this->input_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->input(i));
  }

  // repeated int32 input_dim = 4;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int32Size(this->input_dim_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->input_dim_size());
    total_size += data_size;
  }

  // repeated .opencv_caffe.BlobShape input_shape = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->input_shape_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->input_shape(static_cast<int>(i)));
    }
  }

  // repeated .opencv_caffe.LayerParameter layer = 100;
  {
    unsigned int count = static_cast<unsigned int>(this->layer_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->layer(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 15u) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional .opencv_caffe.NetState state = 6;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->state_);
    }

    // optional bool force_backward = 5 [default = false];
    if (has_force_backward()) {
      total_size += 1 + 1;
    }

    // optional bool debug_info = 7 [default = false];
    if (has_debug_info()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NetParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.NetParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const NetParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NetParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.NetParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.NetParameter)
    MergeFrom(*source);
  }
}

void NetParameter::MergeFrom(const NetParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  layers_.MergeFrom(from.layers_);
  input_.MergeFrom(from.input_);
  input_dim_.MergeFrom(from.input_dim_);
  input_shape_.MergeFrom(from.input_shape_);
  layer_.MergeFrom(from.layer_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_state()->::opencv_caffe::NetState::MergeFrom(from.state());
    }
    if (cached_has_bits & 0x00000004u) {
      force_backward_ = from.force_backward_;
    }
    if (cached_has_bits & 0x00000008u) {
      debug_info_ = from.debug_info_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NetParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.NetParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NetParameter::CopyFrom(const NetParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NetParameter::IsInitialized() const {
  if (!::google::protobuf::internal::AllAreInitialized(this->layer())) return false;
  return true;
}

void NetParameter::Swap(NetParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NetParameter::InternalSwap(NetParameter* other) {
  using std::swap;
  layers_.InternalSwap(&other->layers_);
  input_.InternalSwap(&other->input_);
  input_dim_.InternalSwap(&other->input_dim_);
  input_shape_.InternalSwap(&other->input_shape_);
  layer_.InternalSwap(&other->layer_);
  name_.Swap(&other->name_);
  swap(state_, other->state_);
  swap(force_backward_, other->force_backward_);
  swap(debug_info_, other->debug_info_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NetParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SolverParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_SolverParameter_default_instance_._instance.get_mutable()->net_param_ = const_cast< ::opencv_caffe::NetParameter*>(
      ::opencv_caffe::NetParameter::internal_default_instance());
  ::opencv_caffe::_SolverParameter_default_instance_._instance.get_mutable()->train_net_param_ = const_cast< ::opencv_caffe::NetParameter*>(
      ::opencv_caffe::NetParameter::internal_default_instance());
  ::opencv_caffe::_SolverParameter_default_instance_._instance.get_mutable()->train_state_ = const_cast< ::opencv_caffe::NetState*>(
      ::opencv_caffe::NetState::internal_default_instance());
}
::google::protobuf::internal::ExplicitlyConstructed< ::std::string> SolverParameter::_default_regularization_type_;
::google::protobuf::internal::ExplicitlyConstructed< ::std::string> SolverParameter::_default_type_;
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SolverParameter::kNetFieldNumber;
const int SolverParameter::kNetParamFieldNumber;
const int SolverParameter::kTrainNetFieldNumber;
const int SolverParameter::kTestNetFieldNumber;
const int SolverParameter::kTrainNetParamFieldNumber;
const int SolverParameter::kTestNetParamFieldNumber;
const int SolverParameter::kTrainStateFieldNumber;
const int SolverParameter::kTestStateFieldNumber;
const int SolverParameter::kTestIterFieldNumber;
const int SolverParameter::kTestIntervalFieldNumber;
const int SolverParameter::kTestComputeLossFieldNumber;
const int SolverParameter::kTestInitializationFieldNumber;
const int SolverParameter::kBaseLrFieldNumber;
const int SolverParameter::kDisplayFieldNumber;
const int SolverParameter::kAverageLossFieldNumber;
const int SolverParameter::kMaxIterFieldNumber;
const int SolverParameter::kIterSizeFieldNumber;
const int SolverParameter::kLrPolicyFieldNumber;
const int SolverParameter::kGammaFieldNumber;
const int SolverParameter::kPowerFieldNumber;
const int SolverParameter::kMomentumFieldNumber;
const int SolverParameter::kWeightDecayFieldNumber;
const int SolverParameter::kRegularizationTypeFieldNumber;
const int SolverParameter::kStepsizeFieldNumber;
const int SolverParameter::kStepvalueFieldNumber;
const int SolverParameter::kClipGradientsFieldNumber;
const int SolverParameter::kSnapshotFieldNumber;
const int SolverParameter::kSnapshotPrefixFieldNumber;
const int SolverParameter::kSnapshotDiffFieldNumber;
const int SolverParameter::kSnapshotFormatFieldNumber;
const int SolverParameter::kSolverModeFieldNumber;
const int SolverParameter::kDeviceIdFieldNumber;
const int SolverParameter::kRandomSeedFieldNumber;
const int SolverParameter::kTypeFieldNumber;
const int SolverParameter::kDeltaFieldNumber;
const int SolverParameter::kMomentum2FieldNumber;
const int SolverParameter::kRmsDecayFieldNumber;
const int SolverParameter::kDebugInfoFieldNumber;
const int SolverParameter::kSnapshotAfterTrainFieldNumber;
const int SolverParameter::kSolverTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SolverParameter::SolverParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSolverParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SolverParameter)
}
SolverParameter::SolverParameter(const SolverParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      test_net_(from.test_net_),
      test_iter_(from.test_iter_),
      test_net_param_(from.test_net_param_),
      test_state_(from.test_state_),
      stepvalue_(from.stepvalue_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  train_net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_train_net()) {
    train_net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.train_net_);
  }
  lr_policy_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_lr_policy()) {
    lr_policy_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.lr_policy_);
  }
  snapshot_prefix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_snapshot_prefix()) {
    snapshot_prefix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_prefix_);
  }
  net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_net()) {
    net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.net_);
  }
  regularization_type_.UnsafeSetDefault(&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
  if (from.has_regularization_type()) {
    regularization_type_.AssignWithDefault(&::opencv_caffe::SolverParameter::_default_regularization_type_.get(), from.regularization_type_);
  }
  type_.UnsafeSetDefault(&::opencv_caffe::SolverParameter::_default_type_.get());
  if (from.has_type()) {
    type_.AssignWithDefault(&::opencv_caffe::SolverParameter::_default_type_.get(), from.type_);
  }
  if (from.has_train_net_param()) {
    train_net_param_ = new ::opencv_caffe::NetParameter(*from.train_net_param_);
  } else {
    train_net_param_ = NULL;
  }
  if (from.has_net_param()) {
    net_param_ = new ::opencv_caffe::NetParameter(*from.net_param_);
  } else {
    net_param_ = NULL;
  }
  if (from.has_train_state()) {
    train_state_ = new ::opencv_caffe::NetState(*from.train_state_);
  } else {
    train_state_ = NULL;
  }
  ::memcpy(&test_interval_, &from.test_interval_,
    static_cast<size_t>(reinterpret_cast<char*>(&rms_decay_) -
    reinterpret_cast<char*>(&test_interval_)) + sizeof(rms_decay_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SolverParameter)
}

void SolverParameter::SharedCtor() {
  train_net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  lr_policy_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  snapshot_prefix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  regularization_type_.UnsafeSetDefault(&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
  type_.UnsafeSetDefault(&::opencv_caffe::SolverParameter::_default_type_.get());
  ::memset(&train_net_param_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&solver_type_) -
      reinterpret_cast<char*>(&train_net_param_)) + sizeof(solver_type_));
  momentum2_ = 0.999f;
  random_seed_ = GOOGLE_LONGLONG(-1);
  solver_mode_ = 1;
  test_initialization_ = true;
  snapshot_after_train_ = true;
  delta_ = 1e-08f;
  average_loss_ = 1;
  clip_gradients_ = -1;
  iter_size_ = 1;
  snapshot_format_ = 1;
  rms_decay_ = 0.99f;
  _cached_size_ = 0;
}

SolverParameter::~SolverParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SolverParameter)
  SharedDtor();
}

void SolverParameter::SharedDtor() {
  train_net_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  lr_policy_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  snapshot_prefix_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  net_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  regularization_type_.DestroyNoArena(&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
  type_.DestroyNoArena(&::opencv_caffe::SolverParameter::_default_type_.get());
  if (this != internal_default_instance()) delete train_net_param_;
  if (this != internal_default_instance()) delete net_param_;
  if (this != internal_default_instance()) delete train_state_;
}

void SolverParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SolverParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SolverParameter& SolverParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSolverParameter();
  return *internal_default_instance();
}

SolverParameter* SolverParameter::New(::google::protobuf::Arena* arena) const {
  SolverParameter* n = new SolverParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SolverParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SolverParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  test_net_.Clear();
  test_iter_.Clear();
  test_net_param_.Clear();
  test_state_.Clear();
  stepvalue_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!train_net_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*train_net_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!lr_policy_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*lr_policy_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(!snapshot_prefix_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*snapshot_prefix_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(!net_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*net_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(!regularization_type_.IsDefault(&::opencv_caffe::SolverParameter::_default_regularization_type_.get()));
      (*regularization_type_.UnsafeRawStringPointer())->assign(*&::opencv_caffe::SolverParameter::_default_regularization_type_.get());
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(!type_.IsDefault(&::opencv_caffe::SolverParameter::_default_type_.get()));
      (*type_.UnsafeRawStringPointer())->assign(*&::opencv_caffe::SolverParameter::_default_type_.get());
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(train_net_param_ != NULL);
      train_net_param_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(net_param_ != NULL);
      net_param_->Clear();
    }
  }
  if (cached_has_bits & 0x00000100u) {
    GOOGLE_DCHECK(train_state_ != NULL);
    train_state_->Clear();
  }
  if (cached_has_bits & 65024u) {
    ::memset(&test_interval_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&momentum_) -
        reinterpret_cast<char*>(&test_interval_)) + sizeof(momentum_));
  }
  if (cached_has_bits & 16711680u) {
    ::memset(&weight_decay_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&solver_type_) -
        reinterpret_cast<char*>(&weight_decay_)) + sizeof(solver_type_));
  }
  if (cached_has_bits & 4278190080u) {
    momentum2_ = 0.999f;
    random_seed_ = GOOGLE_LONGLONG(-1);
    solver_mode_ = 1;
    test_initialization_ = true;
    snapshot_after_train_ = true;
    delta_ = 1e-08f;
    average_loss_ = 1;
    clip_gradients_ = -1;
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 7u) {
    iter_size_ = 1;
    snapshot_format_ = 1;
    rms_decay_ = 0.99f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SolverParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SolverParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string train_net = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_train_net()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->train_net().data(), static_cast<int>(this->train_net().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.train_net");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string test_net = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_test_net()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->test_net(this->test_net_size() - 1).data(),
            static_cast<int>(this->test_net(this->test_net_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.test_net");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated int32 test_iter = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24u, input, this->mutable_test_iter())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_test_iter())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 test_interval = 4 [default = 0];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_test_interval();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &test_interval_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float base_lr = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          set_has_base_lr();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &base_lr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 display = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_display();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &display_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 max_iter = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_max_iter();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &max_iter_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string lr_policy = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_lr_policy()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->lr_policy().data(), static_cast<int>(this->lr_policy().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.lr_policy");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float gamma = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(77u /* 77 & 0xFF */)) {
          set_has_gamma();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &gamma_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float power = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(85u /* 85 & 0xFF */)) {
          set_has_power();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &power_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float momentum = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(93u /* 93 & 0xFF */)) {
          set_has_momentum();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &momentum_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float weight_decay = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(101u /* 101 & 0xFF */)) {
          set_has_weight_decay();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &weight_decay_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 stepsize = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) {
          set_has_stepsize();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &stepsize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 snapshot = 14 [default = 0];
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) {
          set_has_snapshot();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &snapshot_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string snapshot_prefix = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(122u /* 122 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_snapshot_prefix()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->snapshot_prefix().data(), static_cast<int>(this->snapshot_prefix().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.snapshot_prefix");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool snapshot_diff = 16 [default = false];
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u /* 128 & 0xFF */)) {
          set_has_snapshot_diff();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &snapshot_diff_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(136u /* 136 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SolverParameter_SolverMode_IsValid(value)) {
            set_solver_mode(static_cast< ::opencv_caffe::SolverParameter_SolverMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                17, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 device_id = 18 [default = 0];
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(144u /* 144 & 0xFF */)) {
          set_has_device_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &device_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool test_compute_loss = 19 [default = false];
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(152u /* 152 & 0xFF */)) {
          set_has_test_compute_loss();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &test_compute_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 random_seed = 20 [default = -1];
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(160u /* 160 & 0xFF */)) {
          set_has_random_seed();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &random_seed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.NetParameter train_net_param = 21;
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u /* 170 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_train_net_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.NetParameter test_net_param = 22;
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u /* 178 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_test_net_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool debug_info = 23 [default = false];
      case 23: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(184u /* 184 & 0xFF */)) {
          set_has_debug_info();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &debug_info_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string net = 24;
      case 24: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u /* 194 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_net()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->net().data(), static_cast<int>(this->net().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.net");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.NetParameter net_param = 25;
      case 25: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(202u /* 202 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_net_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.NetState train_state = 26;
      case 26: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(210u /* 210 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_train_state()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.NetState test_state = 27;
      case 27: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(218u /* 218 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_test_state()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool snapshot_after_train = 28 [default = true];
      case 28: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(224u /* 224 & 0xFF */)) {
          set_has_snapshot_after_train();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &snapshot_after_train_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string regularization_type = 29 [default = "L2"];
      case 29: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(234u /* 234 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_regularization_type()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->regularization_type().data(), static_cast<int>(this->regularization_type().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.regularization_type");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
      case 30: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(240u /* 240 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SolverParameter_SolverType_IsValid(value)) {
            set_solver_type(static_cast< ::opencv_caffe::SolverParameter_SolverType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                30, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float delta = 31 [default = 1e-08];
      case 31: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(253u /* 253 & 0xFF */)) {
          set_has_delta();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &delta_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool test_initialization = 32 [default = true];
      case 32: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(0u /* 256 & 0xFF */)) {
          set_has_test_initialization();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &test_initialization_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 average_loss = 33 [default = 1];
      case 33: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 264 & 0xFF */)) {
          set_has_average_loss();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &average_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated int32 stepvalue = 34;
      case 34: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 272 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 2, 272u, input, this->mutable_stepvalue())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 274 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_stepvalue())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float clip_gradients = 35 [default = -1];
      case 35: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 285 & 0xFF */)) {
          set_has_clip_gradients();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &clip_gradients_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 iter_size = 36 [default = 1];
      case 36: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 288 & 0xFF */)) {
          set_has_iter_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &iter_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
      case 37: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 296 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SolverParameter_SnapshotFormat_IsValid(value)) {
            set_snapshot_format(static_cast< ::opencv_caffe::SolverParameter_SnapshotFormat >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                37, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float rms_decay = 38 [default = 0.99];
      case 38: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(53u /* 309 & 0xFF */)) {
          set_has_rms_decay();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &rms_decay_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float momentum2 = 39 [default = 0.999];
      case 39: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(61u /* 317 & 0xFF */)) {
          set_has_momentum2();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &momentum2_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string type = 40 [default = "SGD"];
      case 40: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 322 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_type()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->type().data(), static_cast<int>(this->type().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverParameter.type");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SolverParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SolverParameter)
  return false;
#undef DO_
}

void SolverParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SolverParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string train_net = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->train_net().data(), static_cast<int>(this->train_net().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.train_net");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->train_net(), output);
  }

  // repeated string test_net = 2;
  for (int i = 0, n = this->test_net_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->test_net(i).data(), static_cast<int>(this->test_net(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.test_net");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->test_net(i), output);
  }

  // repeated int32 test_iter = 3;
  for (int i = 0, n = this->test_iter_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->test_iter(i), output);
  }

  // optional int32 test_interval = 4 [default = 0];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->test_interval(), output);
  }

  // optional float base_lr = 5;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->base_lr(), output);
  }

  // optional int32 display = 6;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->display(), output);
  }

  // optional int32 max_iter = 7;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->max_iter(), output);
  }

  // optional string lr_policy = 8;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->lr_policy().data(), static_cast<int>(this->lr_policy().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.lr_policy");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      8, this->lr_policy(), output);
  }

  // optional float gamma = 9;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->gamma(), output);
  }

  // optional float power = 10;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->power(), output);
  }

  // optional float momentum = 11;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->momentum(), output);
  }

  // optional float weight_decay = 12;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->weight_decay(), output);
  }

  // optional int32 stepsize = 13;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->stepsize(), output);
  }

  // optional int32 snapshot = 14 [default = 0];
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->snapshot(), output);
  }

  // optional string snapshot_prefix = 15;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->snapshot_prefix().data(), static_cast<int>(this->snapshot_prefix().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.snapshot_prefix");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      15, this->snapshot_prefix(), output);
  }

  // optional bool snapshot_diff = 16 [default = false];
  if (cached_has_bits & 0x00200000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->snapshot_diff(), output);
  }

  // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
  if (cached_has_bits & 0x04000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      17, this->solver_mode(), output);
  }

  // optional int32 device_id = 18 [default = 0];
  if (cached_has_bits & 0x00080000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(18, this->device_id(), output);
  }

  // optional bool test_compute_loss = 19 [default = false];
  if (cached_has_bits & 0x00100000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(19, this->test_compute_loss(), output);
  }

  // optional int64 random_seed = 20 [default = -1];
  if (cached_has_bits & 0x02000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(20, this->random_seed(), output);
  }

  // optional .opencv_caffe.NetParameter train_net_param = 21;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      21, *this->train_net_param_, output);
  }

  // repeated .opencv_caffe.NetParameter test_net_param = 22;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->test_net_param_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      22, this->test_net_param(static_cast<int>(i)), output);
  }

  // optional bool debug_info = 23 [default = false];
  if (cached_has_bits & 0x00400000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(23, this->debug_info(), output);
  }

  // optional string net = 24;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->net().data(), static_cast<int>(this->net().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.net");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      24, this->net(), output);
  }

  // optional .opencv_caffe.NetParameter net_param = 25;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      25, *this->net_param_, output);
  }

  // optional .opencv_caffe.NetState train_state = 26;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      26, *this->train_state_, output);
  }

  // repeated .opencv_caffe.NetState test_state = 27;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->test_state_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      27, this->test_state(static_cast<int>(i)), output);
  }

  // optional bool snapshot_after_train = 28 [default = true];
  if (cached_has_bits & 0x10000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(28, this->snapshot_after_train(), output);
  }

  // optional string regularization_type = 29 [default = "L2"];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->regularization_type().data(), static_cast<int>(this->regularization_type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.regularization_type");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      29, this->regularization_type(), output);
  }

  // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
  if (cached_has_bits & 0x00800000u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      30, this->solver_type(), output);
  }

  // optional float delta = 31 [default = 1e-08];
  if (cached_has_bits & 0x20000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(31, this->delta(), output);
  }

  // optional bool test_initialization = 32 [default = true];
  if (cached_has_bits & 0x08000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(32, this->test_initialization(), output);
  }

  // optional int32 average_loss = 33 [default = 1];
  if (cached_has_bits & 0x40000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(33, this->average_loss(), output);
  }

  // repeated int32 stepvalue = 34;
  for (int i = 0, n = this->stepvalue_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      34, this->stepvalue(i), output);
  }

  // optional float clip_gradients = 35 [default = -1];
  if (cached_has_bits & 0x80000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(35, this->clip_gradients(), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional int32 iter_size = 36 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(36, this->iter_size(), output);
  }

  // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      37, this->snapshot_format(), output);
  }

  // optional float rms_decay = 38 [default = 0.99];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(38, this->rms_decay(), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional float momentum2 = 39 [default = 0.999];
  if (cached_has_bits & 0x01000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(39, this->momentum2(), output);
  }

  // optional string type = 40 [default = "SGD"];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.type");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      40, this->type(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SolverParameter)
}

::google::protobuf::uint8* SolverParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SolverParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string train_net = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->train_net().data(), static_cast<int>(this->train_net().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.train_net");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->train_net(), target);
  }

  // repeated string test_net = 2;
  for (int i = 0, n = this->test_net_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->test_net(i).data(), static_cast<int>(this->test_net(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.test_net");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(2, this->test_net(i), target);
  }

  // repeated int32 test_iter = 3;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteInt32ToArray(3, this->test_iter_, target);

  // optional int32 test_interval = 4 [default = 0];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->test_interval(), target);
  }

  // optional float base_lr = 5;
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->base_lr(), target);
  }

  // optional int32 display = 6;
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->display(), target);
  }

  // optional int32 max_iter = 7;
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->max_iter(), target);
  }

  // optional string lr_policy = 8;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->lr_policy().data(), static_cast<int>(this->lr_policy().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.lr_policy");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        8, this->lr_policy(), target);
  }

  // optional float gamma = 9;
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->gamma(), target);
  }

  // optional float power = 10;
  if (cached_has_bits & 0x00004000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->power(), target);
  }

  // optional float momentum = 11;
  if (cached_has_bits & 0x00008000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->momentum(), target);
  }

  // optional float weight_decay = 12;
  if (cached_has_bits & 0x00010000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->weight_decay(), target);
  }

  // optional int32 stepsize = 13;
  if (cached_has_bits & 0x00020000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->stepsize(), target);
  }

  // optional int32 snapshot = 14 [default = 0];
  if (cached_has_bits & 0x00040000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->snapshot(), target);
  }

  // optional string snapshot_prefix = 15;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->snapshot_prefix().data(), static_cast<int>(this->snapshot_prefix().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.snapshot_prefix");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        15, this->snapshot_prefix(), target);
  }

  // optional bool snapshot_diff = 16 [default = false];
  if (cached_has_bits & 0x00200000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->snapshot_diff(), target);
  }

  // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
  if (cached_has_bits & 0x04000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      17, this->solver_mode(), target);
  }

  // optional int32 device_id = 18 [default = 0];
  if (cached_has_bits & 0x00080000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(18, this->device_id(), target);
  }

  // optional bool test_compute_loss = 19 [default = false];
  if (cached_has_bits & 0x00100000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(19, this->test_compute_loss(), target);
  }

  // optional int64 random_seed = 20 [default = -1];
  if (cached_has_bits & 0x02000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(20, this->random_seed(), target);
  }

  // optional .opencv_caffe.NetParameter train_net_param = 21;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        21, *this->train_net_param_, deterministic, target);
  }

  // repeated .opencv_caffe.NetParameter test_net_param = 22;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->test_net_param_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        22, this->test_net_param(static_cast<int>(i)), deterministic, target);
  }

  // optional bool debug_info = 23 [default = false];
  if (cached_has_bits & 0x00400000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(23, this->debug_info(), target);
  }

  // optional string net = 24;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->net().data(), static_cast<int>(this->net().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.net");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        24, this->net(), target);
  }

  // optional .opencv_caffe.NetParameter net_param = 25;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        25, *this->net_param_, deterministic, target);
  }

  // optional .opencv_caffe.NetState train_state = 26;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        26, *this->train_state_, deterministic, target);
  }

  // repeated .opencv_caffe.NetState test_state = 27;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->test_state_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        27, this->test_state(static_cast<int>(i)), deterministic, target);
  }

  // optional bool snapshot_after_train = 28 [default = true];
  if (cached_has_bits & 0x10000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(28, this->snapshot_after_train(), target);
  }

  // optional string regularization_type = 29 [default = "L2"];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->regularization_type().data(), static_cast<int>(this->regularization_type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.regularization_type");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        29, this->regularization_type(), target);
  }

  // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
  if (cached_has_bits & 0x00800000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      30, this->solver_type(), target);
  }

  // optional float delta = 31 [default = 1e-08];
  if (cached_has_bits & 0x20000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(31, this->delta(), target);
  }

  // optional bool test_initialization = 32 [default = true];
  if (cached_has_bits & 0x08000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(32, this->test_initialization(), target);
  }

  // optional int32 average_loss = 33 [default = 1];
  if (cached_has_bits & 0x40000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(33, this->average_loss(), target);
  }

  // repeated int32 stepvalue = 34;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteInt32ToArray(34, this->stepvalue_, target);

  // optional float clip_gradients = 35 [default = -1];
  if (cached_has_bits & 0x80000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(35, this->clip_gradients(), target);
  }

  cached_has_bits = _has_bits_[1];
  // optional int32 iter_size = 36 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(36, this->iter_size(), target);
  }

  // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      37, this->snapshot_format(), target);
  }

  // optional float rms_decay = 38 [default = 0.99];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(38, this->rms_decay(), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional float momentum2 = 39 [default = 0.999];
  if (cached_has_bits & 0x01000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(39, this->momentum2(), target);
  }

  // optional string type = 40 [default = "SGD"];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverParameter.type");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        40, this->type(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SolverParameter)
  return target;
}

size_t SolverParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SolverParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string test_net = 2;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->test_net_size());
  for (int i = 0, n = this->test_net_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->test_net(i));
  }

  // repeated int32 test_iter = 3;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int32Size(this->test_iter_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->test_iter_size());
    total_size += data_size;
  }

  // repeated .opencv_caffe.NetParameter test_net_param = 22;
  {
    unsigned int count = static_cast<unsigned int>(this->test_net_param_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->test_net_param(static_cast<int>(i)));
    }
  }

  // repeated .opencv_caffe.NetState test_state = 27;
  {
    unsigned int count = static_cast<unsigned int>(this->test_state_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->test_state(static_cast<int>(i)));
    }
  }

  // repeated int32 stepvalue = 34;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int32Size(this->stepvalue_);
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->stepvalue_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional string train_net = 1;
    if (has_train_net()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->train_net());
    }

    // optional string lr_policy = 8;
    if (has_lr_policy()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->lr_policy());
    }

    // optional string snapshot_prefix = 15;
    if (has_snapshot_prefix()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->snapshot_prefix());
    }

    // optional string net = 24;
    if (has_net()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->net());
    }

    // optional string regularization_type = 29 [default = "L2"];
    if (has_regularization_type()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->regularization_type());
    }

    // optional string type = 40 [default = "SGD"];
    if (has_type()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->type());
    }

    // optional .opencv_caffe.NetParameter train_net_param = 21;
    if (has_train_net_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->train_net_param_);
    }

    // optional .opencv_caffe.NetParameter net_param = 25;
    if (has_net_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->net_param_);
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional .opencv_caffe.NetState train_state = 26;
    if (has_train_state()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->train_state_);
    }

    // optional int32 test_interval = 4 [default = 0];
    if (has_test_interval()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->test_interval());
    }

    // optional float base_lr = 5;
    if (has_base_lr()) {
      total_size += 1 + 4;
    }

    // optional int32 display = 6;
    if (has_display()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->display());
    }

    // optional int32 max_iter = 7;
    if (has_max_iter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->max_iter());
    }

    // optional float gamma = 9;
    if (has_gamma()) {
      total_size += 1 + 4;
    }

    // optional float power = 10;
    if (has_power()) {
      total_size += 1 + 4;
    }

    // optional float momentum = 11;
    if (has_momentum()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[16 / 32] & 16711680u) {
    // optional float weight_decay = 12;
    if (has_weight_decay()) {
      total_size += 1 + 4;
    }

    // optional int32 stepsize = 13;
    if (has_stepsize()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->stepsize());
    }

    // optional int32 snapshot = 14 [default = 0];
    if (has_snapshot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->snapshot());
    }

    // optional int32 device_id = 18 [default = 0];
    if (has_device_id()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->device_id());
    }

    // optional bool test_compute_loss = 19 [default = false];
    if (has_test_compute_loss()) {
      total_size += 2 + 1;
    }

    // optional bool snapshot_diff = 16 [default = false];
    if (has_snapshot_diff()) {
      total_size += 2 + 1;
    }

    // optional bool debug_info = 23 [default = false];
    if (has_debug_info()) {
      total_size += 2 + 1;
    }

    // optional .opencv_caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
    if (has_solver_type()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->solver_type());
    }

  }
  if (_has_bits_[24 / 32] & 4278190080u) {
    // optional float momentum2 = 39 [default = 0.999];
    if (has_momentum2()) {
      total_size += 2 + 4;
    }

    // optional int64 random_seed = 20 [default = -1];
    if (has_random_seed()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->random_seed());
    }

    // optional .opencv_caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
    if (has_solver_mode()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->solver_mode());
    }

    // optional bool test_initialization = 32 [default = true];
    if (has_test_initialization()) {
      total_size += 2 + 1;
    }

    // optional bool snapshot_after_train = 28 [default = true];
    if (has_snapshot_after_train()) {
      total_size += 2 + 1;
    }

    // optional float delta = 31 [default = 1e-08];
    if (has_delta()) {
      total_size += 2 + 4;
    }

    // optional int32 average_loss = 33 [default = 1];
    if (has_average_loss()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->average_loss());
    }

    // optional float clip_gradients = 35 [default = -1];
    if (has_clip_gradients()) {
      total_size += 2 + 4;
    }

  }
  if (_has_bits_[32 / 32] & 7u) {
    // optional int32 iter_size = 36 [default = 1];
    if (has_iter_size()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->iter_size());
    }

    // optional .opencv_caffe.SolverParameter.SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];
    if (has_snapshot_format()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->snapshot_format());
    }

    // optional float rms_decay = 38 [default = 0.99];
    if (has_rms_decay()) {
      total_size += 2 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SolverParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SolverParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const SolverParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SolverParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SolverParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SolverParameter)
    MergeFrom(*source);
  }
}

void SolverParameter::MergeFrom(const SolverParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SolverParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  test_net_.MergeFrom(from.test_net_);
  test_iter_.MergeFrom(from.test_iter_);
  test_net_param_.MergeFrom(from.test_net_param_);
  test_state_.MergeFrom(from.test_state_);
  stepvalue_.MergeFrom(from.stepvalue_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_train_net();
      train_net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.train_net_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_lr_policy();
      lr_policy_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.lr_policy_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_snapshot_prefix();
      snapshot_prefix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.snapshot_prefix_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_net();
      net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.net_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_regularization_type();
      regularization_type_.AssignWithDefault(&::opencv_caffe::SolverParameter::_default_regularization_type_.get(), from.regularization_type_);
    }
    if (cached_has_bits & 0x00000020u) {
      set_has_type();
      type_.AssignWithDefault(&::opencv_caffe::SolverParameter::_default_type_.get(), from.type_);
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_train_net_param()->::opencv_caffe::NetParameter::MergeFrom(from.train_net_param());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_net_param()->::opencv_caffe::NetParameter::MergeFrom(from.net_param());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      mutable_train_state()->::opencv_caffe::NetState::MergeFrom(from.train_state());
    }
    if (cached_has_bits & 0x00000200u) {
      test_interval_ = from.test_interval_;
    }
    if (cached_has_bits & 0x00000400u) {
      base_lr_ = from.base_lr_;
    }
    if (cached_has_bits & 0x00000800u) {
      display_ = from.display_;
    }
    if (cached_has_bits & 0x00001000u) {
      max_iter_ = from.max_iter_;
    }
    if (cached_has_bits & 0x00002000u) {
      gamma_ = from.gamma_;
    }
    if (cached_has_bits & 0x00004000u) {
      power_ = from.power_;
    }
    if (cached_has_bits & 0x00008000u) {
      momentum_ = from.momentum_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      weight_decay_ = from.weight_decay_;
    }
    if (cached_has_bits & 0x00020000u) {
      stepsize_ = from.stepsize_;
    }
    if (cached_has_bits & 0x00040000u) {
      snapshot_ = from.snapshot_;
    }
    if (cached_has_bits & 0x00080000u) {
      device_id_ = from.device_id_;
    }
    if (cached_has_bits & 0x00100000u) {
      test_compute_loss_ = from.test_compute_loss_;
    }
    if (cached_has_bits & 0x00200000u) {
      snapshot_diff_ = from.snapshot_diff_;
    }
    if (cached_has_bits & 0x00400000u) {
      debug_info_ = from.debug_info_;
    }
    if (cached_has_bits & 0x00800000u) {
      solver_type_ = from.solver_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      momentum2_ = from.momentum2_;
    }
    if (cached_has_bits & 0x02000000u) {
      random_seed_ = from.random_seed_;
    }
    if (cached_has_bits & 0x04000000u) {
      solver_mode_ = from.solver_mode_;
    }
    if (cached_has_bits & 0x08000000u) {
      test_initialization_ = from.test_initialization_;
    }
    if (cached_has_bits & 0x10000000u) {
      snapshot_after_train_ = from.snapshot_after_train_;
    }
    if (cached_has_bits & 0x20000000u) {
      delta_ = from.delta_;
    }
    if (cached_has_bits & 0x40000000u) {
      average_loss_ = from.average_loss_;
    }
    if (cached_has_bits & 0x80000000u) {
      clip_gradients_ = from.clip_gradients_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[1];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      iter_size_ = from.iter_size_;
    }
    if (cached_has_bits & 0x00000002u) {
      snapshot_format_ = from.snapshot_format_;
    }
    if (cached_has_bits & 0x00000004u) {
      rms_decay_ = from.rms_decay_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
}

void SolverParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SolverParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SolverParameter::CopyFrom(const SolverParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SolverParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SolverParameter::IsInitialized() const {
  if (!::google::protobuf::internal::AllAreInitialized(this->test_net_param())) return false;
  if (has_train_net_param()) {
    if (!this->train_net_param_->IsInitialized()) return false;
  }
  if (has_net_param()) {
    if (!this->net_param_->IsInitialized()) return false;
  }
  return true;
}

void SolverParameter::Swap(SolverParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SolverParameter::InternalSwap(SolverParameter* other) {
  using std::swap;
  test_net_.InternalSwap(&other->test_net_);
  test_iter_.InternalSwap(&other->test_iter_);
  test_net_param_.InternalSwap(&other->test_net_param_);
  test_state_.InternalSwap(&other->test_state_);
  stepvalue_.InternalSwap(&other->stepvalue_);
  train_net_.Swap(&other->train_net_);
  lr_policy_.Swap(&other->lr_policy_);
  snapshot_prefix_.Swap(&other->snapshot_prefix_);
  net_.Swap(&other->net_);
  regularization_type_.Swap(&other->regularization_type_);
  type_.Swap(&other->type_);
  swap(train_net_param_, other->train_net_param_);
  swap(net_param_, other->net_param_);
  swap(train_state_, other->train_state_);
  swap(test_interval_, other->test_interval_);
  swap(base_lr_, other->base_lr_);
  swap(display_, other->display_);
  swap(max_iter_, other->max_iter_);
  swap(gamma_, other->gamma_);
  swap(power_, other->power_);
  swap(momentum_, other->momentum_);
  swap(weight_decay_, other->weight_decay_);
  swap(stepsize_, other->stepsize_);
  swap(snapshot_, other->snapshot_);
  swap(device_id_, other->device_id_);
  swap(test_compute_loss_, other->test_compute_loss_);
  swap(snapshot_diff_, other->snapshot_diff_);
  swap(debug_info_, other->debug_info_);
  swap(solver_type_, other->solver_type_);
  swap(momentum2_, other->momentum2_);
  swap(random_seed_, other->random_seed_);
  swap(solver_mode_, other->solver_mode_);
  swap(test_initialization_, other->test_initialization_);
  swap(snapshot_after_train_, other->snapshot_after_train_);
  swap(delta_, other->delta_);
  swap(average_loss_, other->average_loss_);
  swap(clip_gradients_, other->clip_gradients_);
  swap(iter_size_, other->iter_size_);
  swap(snapshot_format_, other->snapshot_format_);
  swap(rms_decay_, other->rms_decay_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SolverParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SolverState::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SolverState::kIterFieldNumber;
const int SolverState::kLearnedNetFieldNumber;
const int SolverState::kHistoryFieldNumber;
const int SolverState::kCurrentStepFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SolverState::SolverState()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSolverState();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SolverState)
}
SolverState::SolverState(const SolverState& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      history_(from.history_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  learned_net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_learned_net()) {
    learned_net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.learned_net_);
  }
  ::memcpy(&iter_, &from.iter_,
    static_cast<size_t>(reinterpret_cast<char*>(&current_step_) -
    reinterpret_cast<char*>(&iter_)) + sizeof(current_step_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SolverState)
}

void SolverState::SharedCtor() {
  _cached_size_ = 0;
  learned_net_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&iter_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&current_step_) -
      reinterpret_cast<char*>(&iter_)) + sizeof(current_step_));
}

SolverState::~SolverState() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SolverState)
  SharedDtor();
}

void SolverState::SharedDtor() {
  learned_net_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void SolverState::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SolverState::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SolverState& SolverState::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSolverState();
  return *internal_default_instance();
}

SolverState* SolverState::New(::google::protobuf::Arena* arena) const {
  SolverState* n = new SolverState;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SolverState::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SolverState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  history_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!learned_net_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*learned_net_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 6u) {
    ::memset(&iter_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&current_step_) -
        reinterpret_cast<char*>(&iter_)) + sizeof(current_step_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SolverState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SolverState)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 iter = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_iter();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &iter_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string learned_net = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_learned_net()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->learned_net().data(), static_cast<int>(this->learned_net().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SolverState.learned_net");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.BlobProto history = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_history()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 current_step = 4 [default = 0];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_current_step();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &current_step_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SolverState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SolverState)
  return false;
#undef DO_
}

void SolverState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SolverState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 iter = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->iter(), output);
  }

  // optional string learned_net = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->learned_net().data(), static_cast<int>(this->learned_net().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverState.learned_net");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->learned_net(), output);
  }

  // repeated .opencv_caffe.BlobProto history = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->history_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->history(static_cast<int>(i)), output);
  }

  // optional int32 current_step = 4 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->current_step(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SolverState)
}

::google::protobuf::uint8* SolverState::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SolverState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 iter = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->iter(), target);
  }

  // optional string learned_net = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->learned_net().data(), static_cast<int>(this->learned_net().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SolverState.learned_net");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->learned_net(), target);
  }

  // repeated .opencv_caffe.BlobProto history = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->history_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->history(static_cast<int>(i)), deterministic, target);
  }

  // optional int32 current_step = 4 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->current_step(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SolverState)
  return target;
}

size_t SolverState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SolverState)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .opencv_caffe.BlobProto history = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->history_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->history(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 7u) {
    // optional string learned_net = 2;
    if (has_learned_net()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->learned_net());
    }

    // optional int32 iter = 1;
    if (has_iter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->iter());
    }

    // optional int32 current_step = 4 [default = 0];
    if (has_current_step()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->current_step());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SolverState::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SolverState)
  GOOGLE_DCHECK_NE(&from, this);
  const SolverState* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SolverState>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SolverState)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SolverState)
    MergeFrom(*source);
  }
}

void SolverState::MergeFrom(const SolverState& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SolverState)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  history_.MergeFrom(from.history_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_learned_net();
      learned_net_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.learned_net_);
    }
    if (cached_has_bits & 0x00000002u) {
      iter_ = from.iter_;
    }
    if (cached_has_bits & 0x00000004u) {
      current_step_ = from.current_step_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SolverState::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SolverState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SolverState::CopyFrom(const SolverState& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SolverState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SolverState::IsInitialized() const {
  return true;
}

void SolverState::Swap(SolverState* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SolverState::InternalSwap(SolverState* other) {
  using std::swap;
  history_.InternalSwap(&other->history_);
  learned_net_.Swap(&other->learned_net_);
  swap(iter_, other->iter_);
  swap(current_step_, other->current_step_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SolverState::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void NetState::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NetState::kPhaseFieldNumber;
const int NetState::kLevelFieldNumber;
const int NetState::kStageFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NetState::NetState()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetState();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.NetState)
}
NetState::NetState(const NetState& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      stage_(from.stage_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&level_, &from.level_,
    static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
    reinterpret_cast<char*>(&level_)) + sizeof(phase_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetState)
}

void NetState::SharedCtor() {
  _cached_size_ = 0;
  level_ = 0;
  phase_ = 1;
}

NetState::~NetState() {
  // @@protoc_insertion_point(destructor:opencv_caffe.NetState)
  SharedDtor();
}

void NetState::SharedDtor() {
}

void NetState::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NetState::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const NetState& NetState::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetState();
  return *internal_default_instance();
}

NetState* NetState::New(::google::protobuf::Arena* arena) const {
  NetState* n = new NetState;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NetState::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.NetState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  stage_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    level_ = 0;
    phase_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NetState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.NetState)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.Phase phase = 1 [default = TEST];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::Phase_IsValid(value)) {
            set_phase(static_cast< ::opencv_caffe::Phase >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 level = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_level();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &level_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string stage = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_stage()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->stage(this->stage_size() - 1).data(),
            static_cast<int>(this->stage(this->stage_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.NetState.stage");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.NetState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.NetState)
  return false;
#undef DO_
}

void NetState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.NetState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.Phase phase = 1 [default = TEST];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->phase(), output);
  }

  // optional int32 level = 2 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->level(), output);
  }

  // repeated string stage = 3;
  for (int i = 0, n = this->stage_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->stage(i).data(), static_cast<int>(this->stage(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetState.stage");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->stage(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.NetState)
}

::google::protobuf::uint8* NetState::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetState)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.Phase phase = 1 [default = TEST];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->phase(), target);
  }

  // optional int32 level = 2 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->level(), target);
  }

  // repeated string stage = 3;
  for (int i = 0, n = this->stage_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->stage(i).data(), static_cast<int>(this->stage(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetState.stage");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(3, this->stage(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetState)
  return target;
}

size_t NetState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetState)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string stage = 3;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->stage_size());
  for (int i = 0, n = this->stage_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->stage(i));
  }

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 level = 2 [default = 0];
    if (has_level()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->level());
    }

    // optional .opencv_caffe.Phase phase = 1 [default = TEST];
    if (has_phase()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->phase());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NetState::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.NetState)
  GOOGLE_DCHECK_NE(&from, this);
  const NetState* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NetState>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.NetState)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.NetState)
    MergeFrom(*source);
  }
}

void NetState::MergeFrom(const NetState& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetState)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  stage_.MergeFrom(from.stage_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      level_ = from.level_;
    }
    if (cached_has_bits & 0x00000002u) {
      phase_ = from.phase_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NetState::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.NetState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NetState::CopyFrom(const NetState& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NetState::IsInitialized() const {
  return true;
}

void NetState::Swap(NetState* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NetState::InternalSwap(NetState* other) {
  using std::swap;
  stage_.InternalSwap(&other->stage_);
  swap(level_, other->level_);
  swap(phase_, other->phase_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NetState::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void NetStateRule::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NetStateRule::kPhaseFieldNumber;
const int NetStateRule::kMinLevelFieldNumber;
const int NetStateRule::kMaxLevelFieldNumber;
const int NetStateRule::kStageFieldNumber;
const int NetStateRule::kNotStageFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NetStateRule::NetStateRule()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetStateRule();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.NetStateRule)
}
NetStateRule::NetStateRule(const NetStateRule& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      stage_(from.stage_),
      not_stage_(from.not_stage_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&phase_, &from.phase_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_level_) -
    reinterpret_cast<char*>(&phase_)) + sizeof(max_level_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.NetStateRule)
}

void NetStateRule::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&phase_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_level_) -
      reinterpret_cast<char*>(&phase_)) + sizeof(max_level_));
}

NetStateRule::~NetStateRule() {
  // @@protoc_insertion_point(destructor:opencv_caffe.NetStateRule)
  SharedDtor();
}

void NetStateRule::SharedDtor() {
}

void NetStateRule::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NetStateRule::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const NetStateRule& NetStateRule::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNetStateRule();
  return *internal_default_instance();
}

NetStateRule* NetStateRule::New(::google::protobuf::Arena* arena) const {
  NetStateRule* n = new NetStateRule;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NetStateRule::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.NetStateRule)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  stage_.Clear();
  not_stage_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ::memset(&phase_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&max_level_) -
        reinterpret_cast<char*>(&phase_)) + sizeof(max_level_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NetStateRule::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.NetStateRule)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.Phase phase = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::Phase_IsValid(value)) {
            set_phase(static_cast< ::opencv_caffe::Phase >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 min_level = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_min_level();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &min_level_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 max_level = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_max_level();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &max_level_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string stage = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_stage()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->stage(this->stage_size() - 1).data(),
            static_cast<int>(this->stage(this->stage_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.NetStateRule.stage");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string not_stage = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_not_stage()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->not_stage(this->not_stage_size() - 1).data(),
            static_cast<int>(this->not_stage(this->not_stage_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.NetStateRule.not_stage");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.NetStateRule)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.NetStateRule)
  return false;
#undef DO_
}

void NetStateRule::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.NetStateRule)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.Phase phase = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->phase(), output);
  }

  // optional int32 min_level = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->min_level(), output);
  }

  // optional int32 max_level = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->max_level(), output);
  }

  // repeated string stage = 4;
  for (int i = 0, n = this->stage_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->stage(i).data(), static_cast<int>(this->stage(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetStateRule.stage");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->stage(i), output);
  }

  // repeated string not_stage = 5;
  for (int i = 0, n = this->not_stage_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->not_stage(i).data(), static_cast<int>(this->not_stage(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetStateRule.not_stage");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->not_stage(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.NetStateRule)
}

::google::protobuf::uint8* NetStateRule::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NetStateRule)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.Phase phase = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->phase(), target);
  }

  // optional int32 min_level = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->min_level(), target);
  }

  // optional int32 max_level = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->max_level(), target);
  }

  // repeated string stage = 4;
  for (int i = 0, n = this->stage_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->stage(i).data(), static_cast<int>(this->stage(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetStateRule.stage");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(4, this->stage(i), target);
  }

  // repeated string not_stage = 5;
  for (int i = 0, n = this->not_stage_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->not_stage(i).data(), static_cast<int>(this->not_stage(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.NetStateRule.not_stage");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(5, this->not_stage(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NetStateRule)
  return target;
}

size_t NetStateRule::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NetStateRule)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string stage = 4;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->stage_size());
  for (int i = 0, n = this->stage_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->stage(i));
  }

  // repeated string not_stage = 5;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->not_stage_size());
  for (int i = 0, n = this->not_stage_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->not_stage(i));
  }

  if (_has_bits_[0 / 32] & 7u) {
    // optional .opencv_caffe.Phase phase = 1;
    if (has_phase()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->phase());
    }

    // optional int32 min_level = 2;
    if (has_min_level()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->min_level());
    }

    // optional int32 max_level = 3;
    if (has_max_level()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->max_level());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NetStateRule::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.NetStateRule)
  GOOGLE_DCHECK_NE(&from, this);
  const NetStateRule* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NetStateRule>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.NetStateRule)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.NetStateRule)
    MergeFrom(*source);
  }
}

void NetStateRule::MergeFrom(const NetStateRule& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NetStateRule)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  stage_.MergeFrom(from.stage_);
  not_stage_.MergeFrom(from.not_stage_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      phase_ = from.phase_;
    }
    if (cached_has_bits & 0x00000002u) {
      min_level_ = from.min_level_;
    }
    if (cached_has_bits & 0x00000004u) {
      max_level_ = from.max_level_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NetStateRule::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.NetStateRule)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NetStateRule::CopyFrom(const NetStateRule& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NetStateRule)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NetStateRule::IsInitialized() const {
  return true;
}

void NetStateRule::Swap(NetStateRule* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NetStateRule::InternalSwap(NetStateRule* other) {
  using std::swap;
  stage_.InternalSwap(&other->stage_);
  not_stage_.InternalSwap(&other->not_stage_);
  swap(phase_, other->phase_);
  swap(min_level_, other->min_level_);
  swap(max_level_, other->max_level_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NetStateRule::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ParamSpec::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ParamSpec::kNameFieldNumber;
const int ParamSpec::kShareModeFieldNumber;
const int ParamSpec::kLrMultFieldNumber;
const int ParamSpec::kDecayMultFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ParamSpec::ParamSpec()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsParamSpec();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ParamSpec)
}
ParamSpec::ParamSpec(const ParamSpec& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  ::memcpy(&share_mode_, &from.share_mode_,
    static_cast<size_t>(reinterpret_cast<char*>(&decay_mult_) -
    reinterpret_cast<char*>(&share_mode_)) + sizeof(decay_mult_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ParamSpec)
}

void ParamSpec::SharedCtor() {
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  share_mode_ = 0;
  lr_mult_ = 1;
  decay_mult_ = 1;
}

ParamSpec::~ParamSpec() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ParamSpec)
  SharedDtor();
}

void ParamSpec::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void ParamSpec::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ParamSpec::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ParamSpec& ParamSpec::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsParamSpec();
  return *internal_default_instance();
}

ParamSpec* ParamSpec::New(::google::protobuf::Arena* arena) const {
  ParamSpec* n = new ParamSpec;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ParamSpec::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ParamSpec)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*name_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 14u) {
    share_mode_ = 0;
    lr_mult_ = 1;
    decay_mult_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ParamSpec::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ParamSpec)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.ParamSpec.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::ParamSpec_DimCheckMode_IsValid(value)) {
            set_share_mode(static_cast< ::opencv_caffe::ParamSpec_DimCheckMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float lr_mult = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_lr_mult();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &lr_mult_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float decay_mult = 4 [default = 1];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
          set_has_decay_mult();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &decay_mult_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ParamSpec)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ParamSpec)
  return false;
#undef DO_
}

void ParamSpec::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ParamSpec)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ParamSpec.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->share_mode(), output);
  }

  // optional float lr_mult = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->lr_mult(), output);
  }

  // optional float decay_mult = 4 [default = 1];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->decay_mult(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ParamSpec)
}

::google::protobuf::uint8* ParamSpec::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ParamSpec)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ParamSpec.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->share_mode(), target);
  }

  // optional float lr_mult = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->lr_mult(), target);
  }

  // optional float decay_mult = 4 [default = 1];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->decay_mult(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ParamSpec)
  return target;
}

size_t ParamSpec::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ParamSpec)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional .opencv_caffe.ParamSpec.DimCheckMode share_mode = 2;
    if (has_share_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->share_mode());
    }

    // optional float lr_mult = 3 [default = 1];
    if (has_lr_mult()) {
      total_size += 1 + 4;
    }

    // optional float decay_mult = 4 [default = 1];
    if (has_decay_mult()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ParamSpec::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ParamSpec)
  GOOGLE_DCHECK_NE(&from, this);
  const ParamSpec* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ParamSpec>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ParamSpec)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ParamSpec)
    MergeFrom(*source);
  }
}

void ParamSpec::MergeFrom(const ParamSpec& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ParamSpec)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      share_mode_ = from.share_mode_;
    }
    if (cached_has_bits & 0x00000004u) {
      lr_mult_ = from.lr_mult_;
    }
    if (cached_has_bits & 0x00000008u) {
      decay_mult_ = from.decay_mult_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ParamSpec::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ParamSpec)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ParamSpec::CopyFrom(const ParamSpec& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ParamSpec)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ParamSpec::IsInitialized() const {
  return true;
}

void ParamSpec::Swap(ParamSpec* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ParamSpec::InternalSwap(ParamSpec* other) {
  using std::swap;
  name_.Swap(&other->name_);
  swap(share_mode_, other->share_mode_);
  swap(lr_mult_, other->lr_mult_);
  swap(decay_mult_, other->decay_mult_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ParamSpec::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void LayerParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->transform_param_ = const_cast< ::opencv_caffe::TransformationParameter*>(
      ::opencv_caffe::TransformationParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->loss_param_ = const_cast< ::opencv_caffe::LossParameter*>(
      ::opencv_caffe::LossParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->accuracy_param_ = const_cast< ::opencv_caffe::AccuracyParameter*>(
      ::opencv_caffe::AccuracyParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->argmax_param_ = const_cast< ::opencv_caffe::ArgMaxParameter*>(
      ::opencv_caffe::ArgMaxParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->batch_norm_param_ = const_cast< ::opencv_caffe::BatchNormParameter*>(
      ::opencv_caffe::BatchNormParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->bias_param_ = const_cast< ::opencv_caffe::BiasParameter*>(
      ::opencv_caffe::BiasParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->concat_param_ = const_cast< ::opencv_caffe::ConcatParameter*>(
      ::opencv_caffe::ConcatParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->contrastive_loss_param_ = const_cast< ::opencv_caffe::ContrastiveLossParameter*>(
      ::opencv_caffe::ContrastiveLossParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->convolution_param_ = const_cast< ::opencv_caffe::ConvolutionParameter*>(
      ::opencv_caffe::ConvolutionParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->crop_param_ = const_cast< ::opencv_caffe::CropParameter*>(
      ::opencv_caffe::CropParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->data_param_ = const_cast< ::opencv_caffe::DataParameter*>(
      ::opencv_caffe::DataParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->detection_output_param_ = const_cast< ::opencv_caffe::DetectionOutputParameter*>(
      ::opencv_caffe::DetectionOutputParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->dropout_param_ = const_cast< ::opencv_caffe::DropoutParameter*>(
      ::opencv_caffe::DropoutParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->dummy_data_param_ = const_cast< ::opencv_caffe::DummyDataParameter*>(
      ::opencv_caffe::DummyDataParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->eltwise_param_ = const_cast< ::opencv_caffe::EltwiseParameter*>(
      ::opencv_caffe::EltwiseParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->elu_param_ = const_cast< ::opencv_caffe::ELUParameter*>(
      ::opencv_caffe::ELUParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->embed_param_ = const_cast< ::opencv_caffe::EmbedParameter*>(
      ::opencv_caffe::EmbedParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->exp_param_ = const_cast< ::opencv_caffe::ExpParameter*>(
      ::opencv_caffe::ExpParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->flatten_param_ = const_cast< ::opencv_caffe::FlattenParameter*>(
      ::opencv_caffe::FlattenParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->hdf5_data_param_ = const_cast< ::opencv_caffe::HDF5DataParameter*>(
      ::opencv_caffe::HDF5DataParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->hdf5_output_param_ = const_cast< ::opencv_caffe::HDF5OutputParameter*>(
      ::opencv_caffe::HDF5OutputParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->hinge_loss_param_ = const_cast< ::opencv_caffe::HingeLossParameter*>(
      ::opencv_caffe::HingeLossParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->image_data_param_ = const_cast< ::opencv_caffe::ImageDataParameter*>(
      ::opencv_caffe::ImageDataParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->infogain_loss_param_ = const_cast< ::opencv_caffe::InfogainLossParameter*>(
      ::opencv_caffe::InfogainLossParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->inner_product_param_ = const_cast< ::opencv_caffe::InnerProductParameter*>(
      ::opencv_caffe::InnerProductParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->input_param_ = const_cast< ::opencv_caffe::InputParameter*>(
      ::opencv_caffe::InputParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->log_param_ = const_cast< ::opencv_caffe::LogParameter*>(
      ::opencv_caffe::LogParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->lrn_param_ = const_cast< ::opencv_caffe::LRNParameter*>(
      ::opencv_caffe::LRNParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->memory_data_param_ = const_cast< ::opencv_caffe::MemoryDataParameter*>(
      ::opencv_caffe::MemoryDataParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->mvn_param_ = const_cast< ::opencv_caffe::MVNParameter*>(
      ::opencv_caffe::MVNParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->norm_param_ = const_cast< ::opencv_caffe::NormalizeBBoxParameter*>(
      ::opencv_caffe::NormalizeBBoxParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->permute_param_ = const_cast< ::opencv_caffe::PermuteParameter*>(
      ::opencv_caffe::PermuteParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->parameter_param_ = const_cast< ::opencv_caffe::ParameterParameter*>(
      ::opencv_caffe::ParameterParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->pooling_param_ = const_cast< ::opencv_caffe::PoolingParameter*>(
      ::opencv_caffe::PoolingParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->power_param_ = const_cast< ::opencv_caffe::PowerParameter*>(
      ::opencv_caffe::PowerParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->prelu_param_ = const_cast< ::opencv_caffe::PReLUParameter*>(
      ::opencv_caffe::PReLUParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->prior_box_param_ = const_cast< ::opencv_caffe::PriorBoxParameter*>(
      ::opencv_caffe::PriorBoxParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->proposal_param_ = const_cast< ::opencv_caffe::ProposalParameter*>(
      ::opencv_caffe::ProposalParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->psroi_pooling_param_ = const_cast< ::opencv_caffe::PSROIPoolingParameter*>(
      ::opencv_caffe::PSROIPoolingParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->python_param_ = const_cast< ::opencv_caffe::PythonParameter*>(
      ::opencv_caffe::PythonParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->recurrent_param_ = const_cast< ::opencv_caffe::RecurrentParameter*>(
      ::opencv_caffe::RecurrentParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->reduction_param_ = const_cast< ::opencv_caffe::ReductionParameter*>(
      ::opencv_caffe::ReductionParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->relu_param_ = const_cast< ::opencv_caffe::ReLUParameter*>(
      ::opencv_caffe::ReLUParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->reshape_param_ = const_cast< ::opencv_caffe::ReshapeParameter*>(
      ::opencv_caffe::ReshapeParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->roi_pooling_param_ = const_cast< ::opencv_caffe::ROIPoolingParameter*>(
      ::opencv_caffe::ROIPoolingParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->scale_param_ = const_cast< ::opencv_caffe::ScaleParameter*>(
      ::opencv_caffe::ScaleParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->sigmoid_param_ = const_cast< ::opencv_caffe::SigmoidParameter*>(
      ::opencv_caffe::SigmoidParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->softmax_param_ = const_cast< ::opencv_caffe::SoftmaxParameter*>(
      ::opencv_caffe::SoftmaxParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->spp_param_ = const_cast< ::opencv_caffe::SPPParameter*>(
      ::opencv_caffe::SPPParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->slice_param_ = const_cast< ::opencv_caffe::SliceParameter*>(
      ::opencv_caffe::SliceParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->tanh_param_ = const_cast< ::opencv_caffe::TanHParameter*>(
      ::opencv_caffe::TanHParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->threshold_param_ = const_cast< ::opencv_caffe::ThresholdParameter*>(
      ::opencv_caffe::ThresholdParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->tile_param_ = const_cast< ::opencv_caffe::TileParameter*>(
      ::opencv_caffe::TileParameter::internal_default_instance());
  ::opencv_caffe::_LayerParameter_default_instance_._instance.get_mutable()->window_data_param_ = const_cast< ::opencv_caffe::WindowDataParameter*>(
      ::opencv_caffe::WindowDataParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int LayerParameter::kNameFieldNumber;
const int LayerParameter::kTypeFieldNumber;
const int LayerParameter::kBottomFieldNumber;
const int LayerParameter::kTopFieldNumber;
const int LayerParameter::kPhaseFieldNumber;
const int LayerParameter::kLossWeightFieldNumber;
const int LayerParameter::kParamFieldNumber;
const int LayerParameter::kBlobsFieldNumber;
const int LayerParameter::kPropagateDownFieldNumber;
const int LayerParameter::kIncludeFieldNumber;
const int LayerParameter::kExcludeFieldNumber;
const int LayerParameter::kTransformParamFieldNumber;
const int LayerParameter::kLossParamFieldNumber;
const int LayerParameter::kAccuracyParamFieldNumber;
const int LayerParameter::kArgmaxParamFieldNumber;
const int LayerParameter::kBatchNormParamFieldNumber;
const int LayerParameter::kBiasParamFieldNumber;
const int LayerParameter::kConcatParamFieldNumber;
const int LayerParameter::kContrastiveLossParamFieldNumber;
const int LayerParameter::kConvolutionParamFieldNumber;
const int LayerParameter::kCropParamFieldNumber;
const int LayerParameter::kDataParamFieldNumber;
const int LayerParameter::kDetectionOutputParamFieldNumber;
const int LayerParameter::kDropoutParamFieldNumber;
const int LayerParameter::kDummyDataParamFieldNumber;
const int LayerParameter::kEltwiseParamFieldNumber;
const int LayerParameter::kEluParamFieldNumber;
const int LayerParameter::kEmbedParamFieldNumber;
const int LayerParameter::kExpParamFieldNumber;
const int LayerParameter::kFlattenParamFieldNumber;
const int LayerParameter::kHdf5DataParamFieldNumber;
const int LayerParameter::kHdf5OutputParamFieldNumber;
const int LayerParameter::kHingeLossParamFieldNumber;
const int LayerParameter::kImageDataParamFieldNumber;
const int LayerParameter::kInfogainLossParamFieldNumber;
const int LayerParameter::kInnerProductParamFieldNumber;
const int LayerParameter::kInputParamFieldNumber;
const int LayerParameter::kLogParamFieldNumber;
const int LayerParameter::kLrnParamFieldNumber;
const int LayerParameter::kMemoryDataParamFieldNumber;
const int LayerParameter::kMvnParamFieldNumber;
const int LayerParameter::kNormParamFieldNumber;
const int LayerParameter::kPermuteParamFieldNumber;
const int LayerParameter::kParameterParamFieldNumber;
const int LayerParameter::kPoolingParamFieldNumber;
const int LayerParameter::kPowerParamFieldNumber;
const int LayerParameter::kPreluParamFieldNumber;
const int LayerParameter::kPriorBoxParamFieldNumber;
const int LayerParameter::kProposalParamFieldNumber;
const int LayerParameter::kPsroiPoolingParamFieldNumber;
const int LayerParameter::kPythonParamFieldNumber;
const int LayerParameter::kRecurrentParamFieldNumber;
const int LayerParameter::kReductionParamFieldNumber;
const int LayerParameter::kReluParamFieldNumber;
const int LayerParameter::kReshapeParamFieldNumber;
const int LayerParameter::kRoiPoolingParamFieldNumber;
const int LayerParameter::kScaleParamFieldNumber;
const int LayerParameter::kSigmoidParamFieldNumber;
const int LayerParameter::kSoftmaxParamFieldNumber;
const int LayerParameter::kSppParamFieldNumber;
const int LayerParameter::kSliceParamFieldNumber;
const int LayerParameter::kTanhParamFieldNumber;
const int LayerParameter::kThresholdParamFieldNumber;
const int LayerParameter::kTileParamFieldNumber;
const int LayerParameter::kWindowDataParamFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

LayerParameter::LayerParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLayerParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.LayerParameter)
}
LayerParameter::LayerParameter(const LayerParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      bottom_(from.bottom_),
      top_(from.top_),
      loss_weight_(from.loss_weight_),
      param_(from.param_),
      blobs_(from.blobs_),
      include_(from.include_),
      exclude_(from.exclude_),
      propagate_down_(from.propagate_down_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_type()) {
    type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
  }
  if (from.has_transform_param()) {
    transform_param_ = new ::opencv_caffe::TransformationParameter(*from.transform_param_);
  } else {
    transform_param_ = NULL;
  }
  if (from.has_loss_param()) {
    loss_param_ = new ::opencv_caffe::LossParameter(*from.loss_param_);
  } else {
    loss_param_ = NULL;
  }
  if (from.has_accuracy_param()) {
    accuracy_param_ = new ::opencv_caffe::AccuracyParameter(*from.accuracy_param_);
  } else {
    accuracy_param_ = NULL;
  }
  if (from.has_argmax_param()) {
    argmax_param_ = new ::opencv_caffe::ArgMaxParameter(*from.argmax_param_);
  } else {
    argmax_param_ = NULL;
  }
  if (from.has_concat_param()) {
    concat_param_ = new ::opencv_caffe::ConcatParameter(*from.concat_param_);
  } else {
    concat_param_ = NULL;
  }
  if (from.has_contrastive_loss_param()) {
    contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter(*from.contrastive_loss_param_);
  } else {
    contrastive_loss_param_ = NULL;
  }
  if (from.has_convolution_param()) {
    convolution_param_ = new ::opencv_caffe::ConvolutionParameter(*from.convolution_param_);
  } else {
    convolution_param_ = NULL;
  }
  if (from.has_data_param()) {
    data_param_ = new ::opencv_caffe::DataParameter(*from.data_param_);
  } else {
    data_param_ = NULL;
  }
  if (from.has_dropout_param()) {
    dropout_param_ = new ::opencv_caffe::DropoutParameter(*from.dropout_param_);
  } else {
    dropout_param_ = NULL;
  }
  if (from.has_dummy_data_param()) {
    dummy_data_param_ = new ::opencv_caffe::DummyDataParameter(*from.dummy_data_param_);
  } else {
    dummy_data_param_ = NULL;
  }
  if (from.has_eltwise_param()) {
    eltwise_param_ = new ::opencv_caffe::EltwiseParameter(*from.eltwise_param_);
  } else {
    eltwise_param_ = NULL;
  }
  if (from.has_exp_param()) {
    exp_param_ = new ::opencv_caffe::ExpParameter(*from.exp_param_);
  } else {
    exp_param_ = NULL;
  }
  if (from.has_hdf5_data_param()) {
    hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter(*from.hdf5_data_param_);
  } else {
    hdf5_data_param_ = NULL;
  }
  if (from.has_hdf5_output_param()) {
    hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_);
  } else {
    hdf5_output_param_ = NULL;
  }
  if (from.has_hinge_loss_param()) {
    hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter(*from.hinge_loss_param_);
  } else {
    hinge_loss_param_ = NULL;
  }
  if (from.has_image_data_param()) {
    image_data_param_ = new ::opencv_caffe::ImageDataParameter(*from.image_data_param_);
  } else {
    image_data_param_ = NULL;
  }
  if (from.has_infogain_loss_param()) {
    infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter(*from.infogain_loss_param_);
  } else {
    infogain_loss_param_ = NULL;
  }
  if (from.has_inner_product_param()) {
    inner_product_param_ = new ::opencv_caffe::InnerProductParameter(*from.inner_product_param_);
  } else {
    inner_product_param_ = NULL;
  }
  if (from.has_lrn_param()) {
    lrn_param_ = new ::opencv_caffe::LRNParameter(*from.lrn_param_);
  } else {
    lrn_param_ = NULL;
  }
  if (from.has_memory_data_param()) {
    memory_data_param_ = new ::opencv_caffe::MemoryDataParameter(*from.memory_data_param_);
  } else {
    memory_data_param_ = NULL;
  }
  if (from.has_mvn_param()) {
    mvn_param_ = new ::opencv_caffe::MVNParameter(*from.mvn_param_);
  } else {
    mvn_param_ = NULL;
  }
  if (from.has_pooling_param()) {
    pooling_param_ = new ::opencv_caffe::PoolingParameter(*from.pooling_param_);
  } else {
    pooling_param_ = NULL;
  }
  if (from.has_power_param()) {
    power_param_ = new ::opencv_caffe::PowerParameter(*from.power_param_);
  } else {
    power_param_ = NULL;
  }
  if (from.has_relu_param()) {
    relu_param_ = new ::opencv_caffe::ReLUParameter(*from.relu_param_);
  } else {
    relu_param_ = NULL;
  }
  if (from.has_sigmoid_param()) {
    sigmoid_param_ = new ::opencv_caffe::SigmoidParameter(*from.sigmoid_param_);
  } else {
    sigmoid_param_ = NULL;
  }
  if (from.has_softmax_param()) {
    softmax_param_ = new ::opencv_caffe::SoftmaxParameter(*from.softmax_param_);
  } else {
    softmax_param_ = NULL;
  }
  if (from.has_slice_param()) {
    slice_param_ = new ::opencv_caffe::SliceParameter(*from.slice_param_);
  } else {
    slice_param_ = NULL;
  }
  if (from.has_tanh_param()) {
    tanh_param_ = new ::opencv_caffe::TanHParameter(*from.tanh_param_);
  } else {
    tanh_param_ = NULL;
  }
  if (from.has_threshold_param()) {
    threshold_param_ = new ::opencv_caffe::ThresholdParameter(*from.threshold_param_);
  } else {
    threshold_param_ = NULL;
  }
  if (from.has_window_data_param()) {
    window_data_param_ = new ::opencv_caffe::WindowDataParameter(*from.window_data_param_);
  } else {
    window_data_param_ = NULL;
  }
  if (from.has_python_param()) {
    python_param_ = new ::opencv_caffe::PythonParameter(*from.python_param_);
  } else {
    python_param_ = NULL;
  }
  if (from.has_prelu_param()) {
    prelu_param_ = new ::opencv_caffe::PReLUParameter(*from.prelu_param_);
  } else {
    prelu_param_ = NULL;
  }
  if (from.has_spp_param()) {
    spp_param_ = new ::opencv_caffe::SPPParameter(*from.spp_param_);
  } else {
    spp_param_ = NULL;
  }
  if (from.has_reshape_param()) {
    reshape_param_ = new ::opencv_caffe::ReshapeParameter(*from.reshape_param_);
  } else {
    reshape_param_ = NULL;
  }
  if (from.has_log_param()) {
    log_param_ = new ::opencv_caffe::LogParameter(*from.log_param_);
  } else {
    log_param_ = NULL;
  }
  if (from.has_flatten_param()) {
    flatten_param_ = new ::opencv_caffe::FlattenParameter(*from.flatten_param_);
  } else {
    flatten_param_ = NULL;
  }
  if (from.has_reduction_param()) {
    reduction_param_ = new ::opencv_caffe::ReductionParameter(*from.reduction_param_);
  } else {
    reduction_param_ = NULL;
  }
  if (from.has_embed_param()) {
    embed_param_ = new ::opencv_caffe::EmbedParameter(*from.embed_param_);
  } else {
    embed_param_ = NULL;
  }
  if (from.has_tile_param()) {
    tile_param_ = new ::opencv_caffe::TileParameter(*from.tile_param_);
  } else {
    tile_param_ = NULL;
  }
  if (from.has_batch_norm_param()) {
    batch_norm_param_ = new ::opencv_caffe::BatchNormParameter(*from.batch_norm_param_);
  } else {
    batch_norm_param_ = NULL;
  }
  if (from.has_elu_param()) {
    elu_param_ = new ::opencv_caffe::ELUParameter(*from.elu_param_);
  } else {
    elu_param_ = NULL;
  }
  if (from.has_bias_param()) {
    bias_param_ = new ::opencv_caffe::BiasParameter(*from.bias_param_);
  } else {
    bias_param_ = NULL;
  }
  if (from.has_scale_param()) {
    scale_param_ = new ::opencv_caffe::ScaleParameter(*from.scale_param_);
  } else {
    scale_param_ = NULL;
  }
  if (from.has_input_param()) {
    input_param_ = new ::opencv_caffe::InputParameter(*from.input_param_);
  } else {
    input_param_ = NULL;
  }
  if (from.has_crop_param()) {
    crop_param_ = new ::opencv_caffe::CropParameter(*from.crop_param_);
  } else {
    crop_param_ = NULL;
  }
  if (from.has_parameter_param()) {
    parameter_param_ = new ::opencv_caffe::ParameterParameter(*from.parameter_param_);
  } else {
    parameter_param_ = NULL;
  }
  if (from.has_recurrent_param()) {
    recurrent_param_ = new ::opencv_caffe::RecurrentParameter(*from.recurrent_param_);
  } else {
    recurrent_param_ = NULL;
  }
  if (from.has_detection_output_param()) {
    detection_output_param_ = new ::opencv_caffe::DetectionOutputParameter(*from.detection_output_param_);
  } else {
    detection_output_param_ = NULL;
  }
  if (from.has_permute_param()) {
    permute_param_ = new ::opencv_caffe::PermuteParameter(*from.permute_param_);
  } else {
    permute_param_ = NULL;
  }
  if (from.has_norm_param()) {
    norm_param_ = new ::opencv_caffe::NormalizeBBoxParameter(*from.norm_param_);
  } else {
    norm_param_ = NULL;
  }
  if (from.has_prior_box_param()) {
    prior_box_param_ = new ::opencv_caffe::PriorBoxParameter(*from.prior_box_param_);
  } else {
    prior_box_param_ = NULL;
  }
  if (from.has_proposal_param()) {
    proposal_param_ = new ::opencv_caffe::ProposalParameter(*from.proposal_param_);
  } else {
    proposal_param_ = NULL;
  }
  if (from.has_psroi_pooling_param()) {
    psroi_pooling_param_ = new ::opencv_caffe::PSROIPoolingParameter(*from.psroi_pooling_param_);
  } else {
    psroi_pooling_param_ = NULL;
  }
  if (from.has_roi_pooling_param()) {
    roi_pooling_param_ = new ::opencv_caffe::ROIPoolingParameter(*from.roi_pooling_param_);
  } else {
    roi_pooling_param_ = NULL;
  }
  phase_ = from.phase_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.LayerParameter)
}

void LayerParameter::SharedCtor() {
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&transform_param_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&phase_) -
      reinterpret_cast<char*>(&transform_param_)) + sizeof(phase_));
  _cached_size_ = 0;
}

LayerParameter::~LayerParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.LayerParameter)
  SharedDtor();
}

void LayerParameter::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete transform_param_;
  if (this != internal_default_instance()) delete loss_param_;
  if (this != internal_default_instance()) delete accuracy_param_;
  if (this != internal_default_instance()) delete argmax_param_;
  if (this != internal_default_instance()) delete concat_param_;
  if (this != internal_default_instance()) delete contrastive_loss_param_;
  if (this != internal_default_instance()) delete convolution_param_;
  if (this != internal_default_instance()) delete data_param_;
  if (this != internal_default_instance()) delete dropout_param_;
  if (this != internal_default_instance()) delete dummy_data_param_;
  if (this != internal_default_instance()) delete eltwise_param_;
  if (this != internal_default_instance()) delete exp_param_;
  if (this != internal_default_instance()) delete hdf5_data_param_;
  if (this != internal_default_instance()) delete hdf5_output_param_;
  if (this != internal_default_instance()) delete hinge_loss_param_;
  if (this != internal_default_instance()) delete image_data_param_;
  if (this != internal_default_instance()) delete infogain_loss_param_;
  if (this != internal_default_instance()) delete inner_product_param_;
  if (this != internal_default_instance()) delete lrn_param_;
  if (this != internal_default_instance()) delete memory_data_param_;
  if (this != internal_default_instance()) delete mvn_param_;
  if (this != internal_default_instance()) delete pooling_param_;
  if (this != internal_default_instance()) delete power_param_;
  if (this != internal_default_instance()) delete relu_param_;
  if (this != internal_default_instance()) delete sigmoid_param_;
  if (this != internal_default_instance()) delete softmax_param_;
  if (this != internal_default_instance()) delete slice_param_;
  if (this != internal_default_instance()) delete tanh_param_;
  if (this != internal_default_instance()) delete threshold_param_;
  if (this != internal_default_instance()) delete window_data_param_;
  if (this != internal_default_instance()) delete python_param_;
  if (this != internal_default_instance()) delete prelu_param_;
  if (this != internal_default_instance()) delete spp_param_;
  if (this != internal_default_instance()) delete reshape_param_;
  if (this != internal_default_instance()) delete log_param_;
  if (this != internal_default_instance()) delete flatten_param_;
  if (this != internal_default_instance()) delete reduction_param_;
  if (this != internal_default_instance()) delete embed_param_;
  if (this != internal_default_instance()) delete tile_param_;
  if (this != internal_default_instance()) delete batch_norm_param_;
  if (this != internal_default_instance()) delete elu_param_;
  if (this != internal_default_instance()) delete bias_param_;
  if (this != internal_default_instance()) delete scale_param_;
  if (this != internal_default_instance()) delete input_param_;
  if (this != internal_default_instance()) delete crop_param_;
  if (this != internal_default_instance()) delete parameter_param_;
  if (this != internal_default_instance()) delete recurrent_param_;
  if (this != internal_default_instance()) delete detection_output_param_;
  if (this != internal_default_instance()) delete permute_param_;
  if (this != internal_default_instance()) delete norm_param_;
  if (this != internal_default_instance()) delete prior_box_param_;
  if (this != internal_default_instance()) delete proposal_param_;
  if (this != internal_default_instance()) delete psroi_pooling_param_;
  if (this != internal_default_instance()) delete roi_pooling_param_;
}

void LayerParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LayerParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const LayerParameter& LayerParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLayerParameter();
  return *internal_default_instance();
}

LayerParameter* LayerParameter::New(::google::protobuf::Arena* arena) const {
  LayerParameter* n = new LayerParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void LayerParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  bottom_.Clear();
  top_.Clear();
  loss_weight_.Clear();
  param_.Clear();
  blobs_.Clear();
  include_.Clear();
  exclude_.Clear();
  propagate_down_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*name_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!type_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*type_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(transform_param_ != NULL);
      transform_param_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(loss_param_ != NULL);
      loss_param_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(accuracy_param_ != NULL);
      accuracy_param_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(argmax_param_ != NULL);
      argmax_param_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(concat_param_ != NULL);
      concat_param_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(contrastive_loss_param_ != NULL);
      contrastive_loss_param_->Clear();
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(convolution_param_ != NULL);
      convolution_param_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(data_param_ != NULL);
      data_param_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(dropout_param_ != NULL);
      dropout_param_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(dummy_data_param_ != NULL);
      dummy_data_param_->Clear();
    }
    if (cached_has_bits & 0x00001000u) {
      GOOGLE_DCHECK(eltwise_param_ != NULL);
      eltwise_param_->Clear();
    }
    if (cached_has_bits & 0x00002000u) {
      GOOGLE_DCHECK(exp_param_ != NULL);
      exp_param_->Clear();
    }
    if (cached_has_bits & 0x00004000u) {
      GOOGLE_DCHECK(hdf5_data_param_ != NULL);
      hdf5_data_param_->Clear();
    }
    if (cached_has_bits & 0x00008000u) {
      GOOGLE_DCHECK(hdf5_output_param_ != NULL);
      hdf5_output_param_->Clear();
    }
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      GOOGLE_DCHECK(hinge_loss_param_ != NULL);
      hinge_loss_param_->Clear();
    }
    if (cached_has_bits & 0x00020000u) {
      GOOGLE_DCHECK(image_data_param_ != NULL);
      image_data_param_->Clear();
    }
    if (cached_has_bits & 0x00040000u) {
      GOOGLE_DCHECK(infogain_loss_param_ != NULL);
      infogain_loss_param_->Clear();
    }
    if (cached_has_bits & 0x00080000u) {
      GOOGLE_DCHECK(inner_product_param_ != NULL);
      inner_product_param_->Clear();
    }
    if (cached_has_bits & 0x00100000u) {
      GOOGLE_DCHECK(lrn_param_ != NULL);
      lrn_param_->Clear();
    }
    if (cached_has_bits & 0x00200000u) {
      GOOGLE_DCHECK(memory_data_param_ != NULL);
      memory_data_param_->Clear();
    }
    if (cached_has_bits & 0x00400000u) {
      GOOGLE_DCHECK(mvn_param_ != NULL);
      mvn_param_->Clear();
    }
    if (cached_has_bits & 0x00800000u) {
      GOOGLE_DCHECK(pooling_param_ != NULL);
      pooling_param_->Clear();
    }
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      GOOGLE_DCHECK(power_param_ != NULL);
      power_param_->Clear();
    }
    if (cached_has_bits & 0x02000000u) {
      GOOGLE_DCHECK(relu_param_ != NULL);
      relu_param_->Clear();
    }
    if (cached_has_bits & 0x04000000u) {
      GOOGLE_DCHECK(sigmoid_param_ != NULL);
      sigmoid_param_->Clear();
    }
    if (cached_has_bits & 0x08000000u) {
      GOOGLE_DCHECK(softmax_param_ != NULL);
      softmax_param_->Clear();
    }
    if (cached_has_bits & 0x10000000u) {
      GOOGLE_DCHECK(slice_param_ != NULL);
      slice_param_->Clear();
    }
    if (cached_has_bits & 0x20000000u) {
      GOOGLE_DCHECK(tanh_param_ != NULL);
      tanh_param_->Clear();
    }
    if (cached_has_bits & 0x40000000u) {
      GOOGLE_DCHECK(threshold_param_ != NULL);
      threshold_param_->Clear();
    }
    if (cached_has_bits & 0x80000000u) {
      GOOGLE_DCHECK(window_data_param_ != NULL);
      window_data_param_->Clear();
    }
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(python_param_ != NULL);
      python_param_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(prelu_param_ != NULL);
      prelu_param_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(spp_param_ != NULL);
      spp_param_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(reshape_param_ != NULL);
      reshape_param_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(log_param_ != NULL);
      log_param_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(flatten_param_ != NULL);
      flatten_param_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(reduction_param_ != NULL);
      reduction_param_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(embed_param_ != NULL);
      embed_param_->Clear();
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(tile_param_ != NULL);
      tile_param_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(batch_norm_param_ != NULL);
      batch_norm_param_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(elu_param_ != NULL);
      elu_param_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(bias_param_ != NULL);
      bias_param_->Clear();
    }
    if (cached_has_bits & 0x00001000u) {
      GOOGLE_DCHECK(scale_param_ != NULL);
      scale_param_->Clear();
    }
    if (cached_has_bits & 0x00002000u) {
      GOOGLE_DCHECK(input_param_ != NULL);
      input_param_->Clear();
    }
    if (cached_has_bits & 0x00004000u) {
      GOOGLE_DCHECK(crop_param_ != NULL);
      crop_param_->Clear();
    }
    if (cached_has_bits & 0x00008000u) {
      GOOGLE_DCHECK(parameter_param_ != NULL);
      parameter_param_->Clear();
    }
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      GOOGLE_DCHECK(recurrent_param_ != NULL);
      recurrent_param_->Clear();
    }
    if (cached_has_bits & 0x00020000u) {
      GOOGLE_DCHECK(detection_output_param_ != NULL);
      detection_output_param_->Clear();
    }
    if (cached_has_bits & 0x00040000u) {
      GOOGLE_DCHECK(permute_param_ != NULL);
      permute_param_->Clear();
    }
    if (cached_has_bits & 0x00080000u) {
      GOOGLE_DCHECK(norm_param_ != NULL);
      norm_param_->Clear();
    }
    if (cached_has_bits & 0x00100000u) {
      GOOGLE_DCHECK(prior_box_param_ != NULL);
      prior_box_param_->Clear();
    }
    if (cached_has_bits & 0x00200000u) {
      GOOGLE_DCHECK(proposal_param_ != NULL);
      proposal_param_->Clear();
    }
    if (cached_has_bits & 0x00400000u) {
      GOOGLE_DCHECK(psroi_pooling_param_ != NULL);
      psroi_pooling_param_->Clear();
    }
    if (cached_has_bits & 0x00800000u) {
      GOOGLE_DCHECK(roi_pooling_param_ != NULL);
      roi_pooling_param_->Clear();
    }
  }
  phase_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool LayerParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.LayerParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(66133690u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.LayerParameter.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string type = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_type()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->type().data(), static_cast<int>(this->type().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.LayerParameter.type");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string bottom = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_bottom()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->bottom(this->bottom_size() - 1).data(),
            static_cast<int>(this->bottom(this->bottom_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.LayerParameter.bottom");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string top = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_top()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->top(this->top_size() - 1).data(),
            static_cast<int>(this->top(this->top_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.LayerParameter.top");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float loss_weight = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 45u, input, this->mutable_loss_weight())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_loss_weight())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.ParamSpec param = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.BlobProto blobs = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_blobs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.NetStateRule include = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_include()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.NetStateRule exclude = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_exclude()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.Phase phase = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::Phase_IsValid(value)) {
            set_phase(static_cast< ::opencv_caffe::Phase >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                10, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated bool propagate_down = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 1, 88u, input, this->mutable_propagate_down())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, this->mutable_propagate_down())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.TransformationParameter transform_param = 100;
      case 100: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 802 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_transform_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LossParameter loss_param = 101;
      case 101: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 810 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
      case 102: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 818 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_accuracy_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
      case 103: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 826 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_argmax_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ConcatParameter concat_param = 104;
      case 104: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 834 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_concat_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
      case 105: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 842 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_contrastive_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
      case 106: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 850 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_convolution_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DataParameter data_param = 107;
      case 107: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 858 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DropoutParameter dropout_param = 108;
      case 108: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 866 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_dropout_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
      case 109: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 874 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_dummy_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
      case 110: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(114u /* 882 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_eltwise_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ExpParameter exp_param = 111;
      case 111: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(122u /* 890 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_exp_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
      case 112: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(130u /* 898 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hdf5_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
      case 113: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(138u /* 906 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hdf5_output_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
      case 114: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 914 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hinge_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ImageDataParameter image_data_param = 115;
      case 115: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(154u /* 922 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_image_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
      case 116: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(162u /* 930 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_infogain_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
      case 117: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u /* 938 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_inner_product_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LRNParameter lrn_param = 118;
      case 118: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u /* 946 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_lrn_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
      case 119: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(186u /* 954 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_memory_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.MVNParameter mvn_param = 120;
      case 120: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u /* 962 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_mvn_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PoolingParameter pooling_param = 121;
      case 121: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(202u /* 970 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_pooling_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PowerParameter power_param = 122;
      case 122: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(210u /* 978 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_power_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ReLUParameter relu_param = 123;
      case 123: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(218u /* 986 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_relu_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
      case 124: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(226u /* 994 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_sigmoid_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
      case 125: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(234u /* 1002 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_softmax_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SliceParameter slice_param = 126;
      case 126: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(242u /* 1010 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_slice_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.TanHParameter tanh_param = 127;
      case 127: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(250u /* 1018 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_tanh_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ThresholdParameter threshold_param = 128;
      case 128: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(2u /* 1026 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_threshold_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.WindowDataParameter window_data_param = 129;
      case 129: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 1034 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_window_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PythonParameter python_param = 130;
      case 130: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 1042 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_python_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PReLUParameter prelu_param = 131;
      case 131: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 1050 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_prelu_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SPPParameter spp_param = 132;
      case 132: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 1058 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_spp_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ReshapeParameter reshape_param = 133;
      case 133: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 1066 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_reshape_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LogParameter log_param = 134;
      case 134: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 1074 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_log_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FlattenParameter flatten_param = 135;
      case 135: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 1082 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_flatten_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ReductionParameter reduction_param = 136;
      case 136: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 1090 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_reduction_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.EmbedParameter embed_param = 137;
      case 137: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 1098 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_embed_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.TileParameter tile_param = 138;
      case 138: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 1106 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_tile_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
      case 139: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 1114 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_batch_norm_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ELUParameter elu_param = 140;
      case 140: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 1122 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_elu_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.BiasParameter bias_param = 141;
      case 141: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 1130 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ScaleParameter scale_param = 142;
      case 142: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(114u /* 1138 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_scale_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.InputParameter input_param = 143;
      case 143: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(122u /* 1146 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_input_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.CropParameter crop_param = 144;
      case 144: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(130u /* 1154 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_crop_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ParameterParameter parameter_param = 145;
      case 145: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(138u /* 1162 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_parameter_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
      case 146: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 1170 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_recurrent_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
      case 147: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(154u /* 1178 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_detection_output_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PermuteParameter permute_param = 148;
      case 148: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(162u /* 1186 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_permute_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
      case 149: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u /* 1194 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_norm_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
      case 150: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u /* 1202 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_prior_box_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ProposalParameter proposal_param = 201;
      case 201: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 1610 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_proposal_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
      case 10002: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 80018 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_psroi_pooling_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
      case 8266711: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(186u /* 66133690 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_roi_pooling_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.LayerParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.LayerParameter)
  return false;
#undef DO_
}

void LayerParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional string type = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.type");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->type(), output);
  }

  // repeated string bottom = 3;
  for (int i = 0, n = this->bottom_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->bottom(i).data(), static_cast<int>(this->bottom(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.bottom");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->bottom(i), output);
  }

  // repeated string top = 4;
  for (int i = 0, n = this->top_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->top(i).data(), static_cast<int>(this->top(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.top");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->top(i), output);
  }

  // repeated float loss_weight = 5;
  for (int i = 0, n = this->loss_weight_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      5, this->loss_weight(i), output);
  }

  // repeated .opencv_caffe.ParamSpec param = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->param_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->param(static_cast<int>(i)), output);
  }

  // repeated .opencv_caffe.BlobProto blobs = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->blobs(static_cast<int>(i)), output);
  }

  // repeated .opencv_caffe.NetStateRule include = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->include_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, this->include(static_cast<int>(i)), output);
  }

  // repeated .opencv_caffe.NetStateRule exclude = 9;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->exclude_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, this->exclude(static_cast<int>(i)), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional .opencv_caffe.Phase phase = 10;
  if (cached_has_bits & 0x01000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      10, this->phase(), output);
  }

  // repeated bool propagate_down = 11;
  for (int i = 0, n = this->propagate_down_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(
      11, this->propagate_down(i), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.TransformationParameter transform_param = 100;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      100, *this->transform_param_, output);
  }

  // optional .opencv_caffe.LossParameter loss_param = 101;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      101, *this->loss_param_, output);
  }

  // optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      102, *this->accuracy_param_, output);
  }

  // optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      103, *this->argmax_param_, output);
  }

  // optional .opencv_caffe.ConcatParameter concat_param = 104;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      104, *this->concat_param_, output);
  }

  // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      105, *this->contrastive_loss_param_, output);
  }

  // optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      106, *this->convolution_param_, output);
  }

  // optional .opencv_caffe.DataParameter data_param = 107;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      107, *this->data_param_, output);
  }

  // optional .opencv_caffe.DropoutParameter dropout_param = 108;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      108, *this->dropout_param_, output);
  }

  // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      109, *this->dummy_data_param_, output);
  }

  // optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      110, *this->eltwise_param_, output);
  }

  // optional .opencv_caffe.ExpParameter exp_param = 111;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      111, *this->exp_param_, output);
  }

  // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      112, *this->hdf5_data_param_, output);
  }

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      113, *this->hdf5_output_param_, output);
  }

  // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      114, *this->hinge_loss_param_, output);
  }

  // optional .opencv_caffe.ImageDataParameter image_data_param = 115;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      115, *this->image_data_param_, output);
  }

  // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      116, *this->infogain_loss_param_, output);
  }

  // optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
  if (cached_has_bits & 0x00080000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      117, *this->inner_product_param_, output);
  }

  // optional .opencv_caffe.LRNParameter lrn_param = 118;
  if (cached_has_bits & 0x00100000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      118, *this->lrn_param_, output);
  }

  // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
  if (cached_has_bits & 0x00200000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      119, *this->memory_data_param_, output);
  }

  // optional .opencv_caffe.MVNParameter mvn_param = 120;
  if (cached_has_bits & 0x00400000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      120, *this->mvn_param_, output);
  }

  // optional .opencv_caffe.PoolingParameter pooling_param = 121;
  if (cached_has_bits & 0x00800000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      121, *this->pooling_param_, output);
  }

  // optional .opencv_caffe.PowerParameter power_param = 122;
  if (cached_has_bits & 0x01000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      122, *this->power_param_, output);
  }

  // optional .opencv_caffe.ReLUParameter relu_param = 123;
  if (cached_has_bits & 0x02000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      123, *this->relu_param_, output);
  }

  // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
  if (cached_has_bits & 0x04000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      124, *this->sigmoid_param_, output);
  }

  // optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
  if (cached_has_bits & 0x08000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      125, *this->softmax_param_, output);
  }

  // optional .opencv_caffe.SliceParameter slice_param = 126;
  if (cached_has_bits & 0x10000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      126, *this->slice_param_, output);
  }

  // optional .opencv_caffe.TanHParameter tanh_param = 127;
  if (cached_has_bits & 0x20000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      127, *this->tanh_param_, output);
  }

  // optional .opencv_caffe.ThresholdParameter threshold_param = 128;
  if (cached_has_bits & 0x40000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      128, *this->threshold_param_, output);
  }

  // optional .opencv_caffe.WindowDataParameter window_data_param = 129;
  if (cached_has_bits & 0x80000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      129, *this->window_data_param_, output);
  }

  cached_has_bits = _has_bits_[1];
  // optional .opencv_caffe.PythonParameter python_param = 130;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      130, *this->python_param_, output);
  }

  // optional .opencv_caffe.PReLUParameter prelu_param = 131;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      131, *this->prelu_param_, output);
  }

  // optional .opencv_caffe.SPPParameter spp_param = 132;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      132, *this->spp_param_, output);
  }

  // optional .opencv_caffe.ReshapeParameter reshape_param = 133;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      133, *this->reshape_param_, output);
  }

  // optional .opencv_caffe.LogParameter log_param = 134;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      134, *this->log_param_, output);
  }

  // optional .opencv_caffe.FlattenParameter flatten_param = 135;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      135, *this->flatten_param_, output);
  }

  // optional .opencv_caffe.ReductionParameter reduction_param = 136;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      136, *this->reduction_param_, output);
  }

  // optional .opencv_caffe.EmbedParameter embed_param = 137;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      137, *this->embed_param_, output);
  }

  // optional .opencv_caffe.TileParameter tile_param = 138;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      138, *this->tile_param_, output);
  }

  // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      139, *this->batch_norm_param_, output);
  }

  // optional .opencv_caffe.ELUParameter elu_param = 140;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      140, *this->elu_param_, output);
  }

  // optional .opencv_caffe.BiasParameter bias_param = 141;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      141, *this->bias_param_, output);
  }

  // optional .opencv_caffe.ScaleParameter scale_param = 142;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      142, *this->scale_param_, output);
  }

  // optional .opencv_caffe.InputParameter input_param = 143;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      143, *this->input_param_, output);
  }

  // optional .opencv_caffe.CropParameter crop_param = 144;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      144, *this->crop_param_, output);
  }

  // optional .opencv_caffe.ParameterParameter parameter_param = 145;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      145, *this->parameter_param_, output);
  }

  // optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      146, *this->recurrent_param_, output);
  }

  // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      147, *this->detection_output_param_, output);
  }

  // optional .opencv_caffe.PermuteParameter permute_param = 148;
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      148, *this->permute_param_, output);
  }

  // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
  if (cached_has_bits & 0x00080000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      149, *this->norm_param_, output);
  }

  // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
  if (cached_has_bits & 0x00100000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      150, *this->prior_box_param_, output);
  }

  // optional .opencv_caffe.ProposalParameter proposal_param = 201;
  if (cached_has_bits & 0x00200000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      201, *this->proposal_param_, output);
  }

  // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
  if (cached_has_bits & 0x00400000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      10002, *this->psroi_pooling_param_, output);
  }

  // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
  if (cached_has_bits & 0x00800000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8266711, *this->roi_pooling_param_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.LayerParameter)
}

::google::protobuf::uint8* LayerParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional string type = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.type");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->type(), target);
  }

  // repeated string bottom = 3;
  for (int i = 0, n = this->bottom_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->bottom(i).data(), static_cast<int>(this->bottom(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.bottom");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(3, this->bottom(i), target);
  }

  // repeated string top = 4;
  for (int i = 0, n = this->top_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->top(i).data(), static_cast<int>(this->top(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.LayerParameter.top");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(4, this->top(i), target);
  }

  // repeated float loss_weight = 5;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(5, this->loss_weight_, target);

  // repeated .opencv_caffe.ParamSpec param = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->param_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, this->param(static_cast<int>(i)), deterministic, target);
  }

  // repeated .opencv_caffe.BlobProto blobs = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        7, this->blobs(static_cast<int>(i)), deterministic, target);
  }

  // repeated .opencv_caffe.NetStateRule include = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->include_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, this->include(static_cast<int>(i)), deterministic, target);
  }

  // repeated .opencv_caffe.NetStateRule exclude = 9;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->exclude_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        9, this->exclude(static_cast<int>(i)), deterministic, target);
  }

  cached_has_bits = _has_bits_[1];
  // optional .opencv_caffe.Phase phase = 10;
  if (cached_has_bits & 0x01000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      10, this->phase(), target);
  }

  // repeated bool propagate_down = 11;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteBoolToArray(11, this->propagate_down_, target);

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.TransformationParameter transform_param = 100;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        100, *this->transform_param_, deterministic, target);
  }

  // optional .opencv_caffe.LossParameter loss_param = 101;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        101, *this->loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        102, *this->accuracy_param_, deterministic, target);
  }

  // optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        103, *this->argmax_param_, deterministic, target);
  }

  // optional .opencv_caffe.ConcatParameter concat_param = 104;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        104, *this->concat_param_, deterministic, target);
  }

  // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        105, *this->contrastive_loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        106, *this->convolution_param_, deterministic, target);
  }

  // optional .opencv_caffe.DataParameter data_param = 107;
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        107, *this->data_param_, deterministic, target);
  }

  // optional .opencv_caffe.DropoutParameter dropout_param = 108;
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        108, *this->dropout_param_, deterministic, target);
  }

  // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        109, *this->dummy_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        110, *this->eltwise_param_, deterministic, target);
  }

  // optional .opencv_caffe.ExpParameter exp_param = 111;
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        111, *this->exp_param_, deterministic, target);
  }

  // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
  if (cached_has_bits & 0x00004000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        112, *this->hdf5_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
  if (cached_has_bits & 0x00008000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        113, *this->hdf5_output_param_, deterministic, target);
  }

  // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
  if (cached_has_bits & 0x00010000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        114, *this->hinge_loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.ImageDataParameter image_data_param = 115;
  if (cached_has_bits & 0x00020000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        115, *this->image_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
  if (cached_has_bits & 0x00040000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        116, *this->infogain_loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
  if (cached_has_bits & 0x00080000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        117, *this->inner_product_param_, deterministic, target);
  }

  // optional .opencv_caffe.LRNParameter lrn_param = 118;
  if (cached_has_bits & 0x00100000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        118, *this->lrn_param_, deterministic, target);
  }

  // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
  if (cached_has_bits & 0x00200000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        119, *this->memory_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.MVNParameter mvn_param = 120;
  if (cached_has_bits & 0x00400000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        120, *this->mvn_param_, deterministic, target);
  }

  // optional .opencv_caffe.PoolingParameter pooling_param = 121;
  if (cached_has_bits & 0x00800000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        121, *this->pooling_param_, deterministic, target);
  }

  // optional .opencv_caffe.PowerParameter power_param = 122;
  if (cached_has_bits & 0x01000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        122, *this->power_param_, deterministic, target);
  }

  // optional .opencv_caffe.ReLUParameter relu_param = 123;
  if (cached_has_bits & 0x02000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        123, *this->relu_param_, deterministic, target);
  }

  // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
  if (cached_has_bits & 0x04000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        124, *this->sigmoid_param_, deterministic, target);
  }

  // optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
  if (cached_has_bits & 0x08000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        125, *this->softmax_param_, deterministic, target);
  }

  // optional .opencv_caffe.SliceParameter slice_param = 126;
  if (cached_has_bits & 0x10000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        126, *this->slice_param_, deterministic, target);
  }

  // optional .opencv_caffe.TanHParameter tanh_param = 127;
  if (cached_has_bits & 0x20000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        127, *this->tanh_param_, deterministic, target);
  }

  // optional .opencv_caffe.ThresholdParameter threshold_param = 128;
  if (cached_has_bits & 0x40000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        128, *this->threshold_param_, deterministic, target);
  }

  // optional .opencv_caffe.WindowDataParameter window_data_param = 129;
  if (cached_has_bits & 0x80000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        129, *this->window_data_param_, deterministic, target);
  }

  cached_has_bits = _has_bits_[1];
  // optional .opencv_caffe.PythonParameter python_param = 130;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        130, *this->python_param_, deterministic, target);
  }

  // optional .opencv_caffe.PReLUParameter prelu_param = 131;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        131, *this->prelu_param_, deterministic, target);
  }

  // optional .opencv_caffe.SPPParameter spp_param = 132;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        132, *this->spp_param_, deterministic, target);
  }

  // optional .opencv_caffe.ReshapeParameter reshape_param = 133;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        133, *this->reshape_param_, deterministic, target);
  }

  // optional .opencv_caffe.LogParameter log_param = 134;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        134, *this->log_param_, deterministic, target);
  }

  // optional .opencv_caffe.FlattenParameter flatten_param = 135;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        135, *this->flatten_param_, deterministic, target);
  }

  // optional .opencv_caffe.ReductionParameter reduction_param = 136;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        136, *this->reduction_param_, deterministic, target);
  }

  // optional .opencv_caffe.EmbedParameter embed_param = 137;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        137, *this->embed_param_, deterministic, target);
  }

  // optional .opencv_caffe.TileParameter tile_param = 138;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        138, *this->tile_param_, deterministic, target);
  }

  // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        139, *this->batch_norm_param_, deterministic, target);
  }

  // optional .opencv_caffe.ELUParameter elu_param = 140;
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        140, *this->elu_param_, deterministic, target);
  }

  // optional .opencv_caffe.BiasParameter bias_param = 141;
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        141, *this->bias_param_, deterministic, target);
  }

  // optional .opencv_caffe.ScaleParameter scale_param = 142;
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        142, *this->scale_param_, deterministic, target);
  }

  // optional .opencv_caffe.InputParameter input_param = 143;
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        143, *this->input_param_, deterministic, target);
  }

  // optional .opencv_caffe.CropParameter crop_param = 144;
  if (cached_has_bits & 0x00004000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        144, *this->crop_param_, deterministic, target);
  }

  // optional .opencv_caffe.ParameterParameter parameter_param = 145;
  if (cached_has_bits & 0x00008000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        145, *this->parameter_param_, deterministic, target);
  }

  // optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
  if (cached_has_bits & 0x00010000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        146, *this->recurrent_param_, deterministic, target);
  }

  // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
  if (cached_has_bits & 0x00020000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        147, *this->detection_output_param_, deterministic, target);
  }

  // optional .opencv_caffe.PermuteParameter permute_param = 148;
  if (cached_has_bits & 0x00040000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        148, *this->permute_param_, deterministic, target);
  }

  // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
  if (cached_has_bits & 0x00080000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        149, *this->norm_param_, deterministic, target);
  }

  // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
  if (cached_has_bits & 0x00100000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        150, *this->prior_box_param_, deterministic, target);
  }

  // optional .opencv_caffe.ProposalParameter proposal_param = 201;
  if (cached_has_bits & 0x00200000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        201, *this->proposal_param_, deterministic, target);
  }

  // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
  if (cached_has_bits & 0x00400000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        10002, *this->psroi_pooling_param_, deterministic, target);
  }

  // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
  if (cached_has_bits & 0x00800000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8266711, *this->roi_pooling_param_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LayerParameter)
  return target;
}

size_t LayerParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LayerParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string bottom = 3;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->bottom_size());
  for (int i = 0, n = this->bottom_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->bottom(i));
  }

  // repeated string top = 4;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->top_size());
  for (int i = 0, n = this->top_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->top(i));
  }

  // repeated float loss_weight = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->loss_weight_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->loss_weight_size());
    total_size += data_size;
  }

  // repeated .opencv_caffe.ParamSpec param = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->param_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->param(static_cast<int>(i)));
    }
  }

  // repeated .opencv_caffe.BlobProto blobs = 7;
  {
    unsigned int count = static_cast<unsigned int>(this->blobs_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->blobs(static_cast<int>(i)));
    }
  }

  // repeated .opencv_caffe.NetStateRule include = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->include_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->include(static_cast<int>(i)));
    }
  }

  // repeated .opencv_caffe.NetStateRule exclude = 9;
  {
    unsigned int count = static_cast<unsigned int>(this->exclude_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->exclude(static_cast<int>(i)));
    }
  }

  // repeated bool propagate_down = 11;
  {
    unsigned int count = static_cast<unsigned int>(this->propagate_down_size());
    size_t data_size = 1UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->propagate_down_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string type = 2;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->type());
    }

    // optional .opencv_caffe.TransformationParameter transform_param = 100;
    if (has_transform_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->transform_param_);
    }

    // optional .opencv_caffe.LossParameter loss_param = 101;
    if (has_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->loss_param_);
    }

    // optional .opencv_caffe.AccuracyParameter accuracy_param = 102;
    if (has_accuracy_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->accuracy_param_);
    }

    // optional .opencv_caffe.ArgMaxParameter argmax_param = 103;
    if (has_argmax_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->argmax_param_);
    }

    // optional .opencv_caffe.ConcatParameter concat_param = 104;
    if (has_concat_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->concat_param_);
    }

    // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 105;
    if (has_contrastive_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->contrastive_loss_param_);
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional .opencv_caffe.ConvolutionParameter convolution_param = 106;
    if (has_convolution_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->convolution_param_);
    }

    // optional .opencv_caffe.DataParameter data_param = 107;
    if (has_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->data_param_);
    }

    // optional .opencv_caffe.DropoutParameter dropout_param = 108;
    if (has_dropout_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->dropout_param_);
    }

    // optional .opencv_caffe.DummyDataParameter dummy_data_param = 109;
    if (has_dummy_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->dummy_data_param_);
    }

    // optional .opencv_caffe.EltwiseParameter eltwise_param = 110;
    if (has_eltwise_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->eltwise_param_);
    }

    // optional .opencv_caffe.ExpParameter exp_param = 111;
    if (has_exp_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->exp_param_);
    }

    // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 112;
    if (has_hdf5_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hdf5_data_param_);
    }

    // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 113;
    if (has_hdf5_output_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hdf5_output_param_);
    }

  }
  if (_has_bits_[16 / 32] & 16711680u) {
    // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 114;
    if (has_hinge_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hinge_loss_param_);
    }

    // optional .opencv_caffe.ImageDataParameter image_data_param = 115;
    if (has_image_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->image_data_param_);
    }

    // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 116;
    if (has_infogain_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->infogain_loss_param_);
    }

    // optional .opencv_caffe.InnerProductParameter inner_product_param = 117;
    if (has_inner_product_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->inner_product_param_);
    }

    // optional .opencv_caffe.LRNParameter lrn_param = 118;
    if (has_lrn_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->lrn_param_);
    }

    // optional .opencv_caffe.MemoryDataParameter memory_data_param = 119;
    if (has_memory_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->memory_data_param_);
    }

    // optional .opencv_caffe.MVNParameter mvn_param = 120;
    if (has_mvn_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->mvn_param_);
    }

    // optional .opencv_caffe.PoolingParameter pooling_param = 121;
    if (has_pooling_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->pooling_param_);
    }

  }
  if (_has_bits_[24 / 32] & 4278190080u) {
    // optional .opencv_caffe.PowerParameter power_param = 122;
    if (has_power_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->power_param_);
    }

    // optional .opencv_caffe.ReLUParameter relu_param = 123;
    if (has_relu_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->relu_param_);
    }

    // optional .opencv_caffe.SigmoidParameter sigmoid_param = 124;
    if (has_sigmoid_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->sigmoid_param_);
    }

    // optional .opencv_caffe.SoftmaxParameter softmax_param = 125;
    if (has_softmax_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->softmax_param_);
    }

    // optional .opencv_caffe.SliceParameter slice_param = 126;
    if (has_slice_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->slice_param_);
    }

    // optional .opencv_caffe.TanHParameter tanh_param = 127;
    if (has_tanh_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->tanh_param_);
    }

    // optional .opencv_caffe.ThresholdParameter threshold_param = 128;
    if (has_threshold_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->threshold_param_);
    }

    // optional .opencv_caffe.WindowDataParameter window_data_param = 129;
    if (has_window_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->window_data_param_);
    }

  }
  if (_has_bits_[32 / 32] & 255u) {
    // optional .opencv_caffe.PythonParameter python_param = 130;
    if (has_python_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->python_param_);
    }

    // optional .opencv_caffe.PReLUParameter prelu_param = 131;
    if (has_prelu_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->prelu_param_);
    }

    // optional .opencv_caffe.SPPParameter spp_param = 132;
    if (has_spp_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->spp_param_);
    }

    // optional .opencv_caffe.ReshapeParameter reshape_param = 133;
    if (has_reshape_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->reshape_param_);
    }

    // optional .opencv_caffe.LogParameter log_param = 134;
    if (has_log_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->log_param_);
    }

    // optional .opencv_caffe.FlattenParameter flatten_param = 135;
    if (has_flatten_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->flatten_param_);
    }

    // optional .opencv_caffe.ReductionParameter reduction_param = 136;
    if (has_reduction_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->reduction_param_);
    }

    // optional .opencv_caffe.EmbedParameter embed_param = 137;
    if (has_embed_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->embed_param_);
    }

  }
  if (_has_bits_[40 / 32] & 65280u) {
    // optional .opencv_caffe.TileParameter tile_param = 138;
    if (has_tile_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->tile_param_);
    }

    // optional .opencv_caffe.BatchNormParameter batch_norm_param = 139;
    if (has_batch_norm_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->batch_norm_param_);
    }

    // optional .opencv_caffe.ELUParameter elu_param = 140;
    if (has_elu_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->elu_param_);
    }

    // optional .opencv_caffe.BiasParameter bias_param = 141;
    if (has_bias_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_param_);
    }

    // optional .opencv_caffe.ScaleParameter scale_param = 142;
    if (has_scale_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->scale_param_);
    }

    // optional .opencv_caffe.InputParameter input_param = 143;
    if (has_input_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->input_param_);
    }

    // optional .opencv_caffe.CropParameter crop_param = 144;
    if (has_crop_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->crop_param_);
    }

    // optional .opencv_caffe.ParameterParameter parameter_param = 145;
    if (has_parameter_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->parameter_param_);
    }

  }
  if (_has_bits_[48 / 32] & 16711680u) {
    // optional .opencv_caffe.RecurrentParameter recurrent_param = 146;
    if (has_recurrent_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->recurrent_param_);
    }

    // optional .opencv_caffe.DetectionOutputParameter detection_output_param = 147;
    if (has_detection_output_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->detection_output_param_);
    }

    // optional .opencv_caffe.PermuteParameter permute_param = 148;
    if (has_permute_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->permute_param_);
    }

    // optional .opencv_caffe.NormalizeBBoxParameter norm_param = 149;
    if (has_norm_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->norm_param_);
    }

    // optional .opencv_caffe.PriorBoxParameter prior_box_param = 150;
    if (has_prior_box_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->prior_box_param_);
    }

    // optional .opencv_caffe.ProposalParameter proposal_param = 201;
    if (has_proposal_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->proposal_param_);
    }

    // optional .opencv_caffe.PSROIPoolingParameter psroi_pooling_param = 10002;
    if (has_psroi_pooling_param()) {
      total_size += 3 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->psroi_pooling_param_);
    }

    // optional .opencv_caffe.ROIPoolingParameter roi_pooling_param = 8266711;
    if (has_roi_pooling_param()) {
      total_size += 4 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->roi_pooling_param_);
    }

  }
  // optional .opencv_caffe.Phase phase = 10;
  if (has_phase()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->phase());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LayerParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.LayerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const LayerParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const LayerParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.LayerParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.LayerParameter)
    MergeFrom(*source);
  }
}

void LayerParameter::MergeFrom(const LayerParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LayerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  bottom_.MergeFrom(from.bottom_);
  top_.MergeFrom(from.top_);
  loss_weight_.MergeFrom(from.loss_weight_);
  param_.MergeFrom(from.param_);
  blobs_.MergeFrom(from.blobs_);
  include_.MergeFrom(from.include_);
  exclude_.MergeFrom(from.exclude_);
  propagate_down_.MergeFrom(from.propagate_down_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_type();
      type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_transform_param()->::opencv_caffe::TransformationParameter::MergeFrom(from.transform_param());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_loss_param()->::opencv_caffe::LossParameter::MergeFrom(from.loss_param());
    }
    if (cached_has_bits & 0x00000010u) {
      mutable_accuracy_param()->::opencv_caffe::AccuracyParameter::MergeFrom(from.accuracy_param());
    }
    if (cached_has_bits & 0x00000020u) {
      mutable_argmax_param()->::opencv_caffe::ArgMaxParameter::MergeFrom(from.argmax_param());
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_concat_param()->::opencv_caffe::ConcatParameter::MergeFrom(from.concat_param());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_contrastive_loss_param()->::opencv_caffe::ContrastiveLossParameter::MergeFrom(from.contrastive_loss_param());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      mutable_convolution_param()->::opencv_caffe::ConvolutionParameter::MergeFrom(from.convolution_param());
    }
    if (cached_has_bits & 0x00000200u) {
      mutable_data_param()->::opencv_caffe::DataParameter::MergeFrom(from.data_param());
    }
    if (cached_has_bits & 0x00000400u) {
      mutable_dropout_param()->::opencv_caffe::DropoutParameter::MergeFrom(from.dropout_param());
    }
    if (cached_has_bits & 0x00000800u) {
      mutable_dummy_data_param()->::opencv_caffe::DummyDataParameter::MergeFrom(from.dummy_data_param());
    }
    if (cached_has_bits & 0x00001000u) {
      mutable_eltwise_param()->::opencv_caffe::EltwiseParameter::MergeFrom(from.eltwise_param());
    }
    if (cached_has_bits & 0x00002000u) {
      mutable_exp_param()->::opencv_caffe::ExpParameter::MergeFrom(from.exp_param());
    }
    if (cached_has_bits & 0x00004000u) {
      mutable_hdf5_data_param()->::opencv_caffe::HDF5DataParameter::MergeFrom(from.hdf5_data_param());
    }
    if (cached_has_bits & 0x00008000u) {
      mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from.hdf5_output_param());
    }
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      mutable_hinge_loss_param()->::opencv_caffe::HingeLossParameter::MergeFrom(from.hinge_loss_param());
    }
    if (cached_has_bits & 0x00020000u) {
      mutable_image_data_param()->::opencv_caffe::ImageDataParameter::MergeFrom(from.image_data_param());
    }
    if (cached_has_bits & 0x00040000u) {
      mutable_infogain_loss_param()->::opencv_caffe::InfogainLossParameter::MergeFrom(from.infogain_loss_param());
    }
    if (cached_has_bits & 0x00080000u) {
      mutable_inner_product_param()->::opencv_caffe::InnerProductParameter::MergeFrom(from.inner_product_param());
    }
    if (cached_has_bits & 0x00100000u) {
      mutable_lrn_param()->::opencv_caffe::LRNParameter::MergeFrom(from.lrn_param());
    }
    if (cached_has_bits & 0x00200000u) {
      mutable_memory_data_param()->::opencv_caffe::MemoryDataParameter::MergeFrom(from.memory_data_param());
    }
    if (cached_has_bits & 0x00400000u) {
      mutable_mvn_param()->::opencv_caffe::MVNParameter::MergeFrom(from.mvn_param());
    }
    if (cached_has_bits & 0x00800000u) {
      mutable_pooling_param()->::opencv_caffe::PoolingParameter::MergeFrom(from.pooling_param());
    }
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      mutable_power_param()->::opencv_caffe::PowerParameter::MergeFrom(from.power_param());
    }
    if (cached_has_bits & 0x02000000u) {
      mutable_relu_param()->::opencv_caffe::ReLUParameter::MergeFrom(from.relu_param());
    }
    if (cached_has_bits & 0x04000000u) {
      mutable_sigmoid_param()->::opencv_caffe::SigmoidParameter::MergeFrom(from.sigmoid_param());
    }
    if (cached_has_bits & 0x08000000u) {
      mutable_softmax_param()->::opencv_caffe::SoftmaxParameter::MergeFrom(from.softmax_param());
    }
    if (cached_has_bits & 0x10000000u) {
      mutable_slice_param()->::opencv_caffe::SliceParameter::MergeFrom(from.slice_param());
    }
    if (cached_has_bits & 0x20000000u) {
      mutable_tanh_param()->::opencv_caffe::TanHParameter::MergeFrom(from.tanh_param());
    }
    if (cached_has_bits & 0x40000000u) {
      mutable_threshold_param()->::opencv_caffe::ThresholdParameter::MergeFrom(from.threshold_param());
    }
    if (cached_has_bits & 0x80000000u) {
      mutable_window_data_param()->::opencv_caffe::WindowDataParameter::MergeFrom(from.window_data_param());
    }
  }
  cached_has_bits = from._has_bits_[1];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_python_param()->::opencv_caffe::PythonParameter::MergeFrom(from.python_param());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_prelu_param()->::opencv_caffe::PReLUParameter::MergeFrom(from.prelu_param());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_spp_param()->::opencv_caffe::SPPParameter::MergeFrom(from.spp_param());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_reshape_param()->::opencv_caffe::ReshapeParameter::MergeFrom(from.reshape_param());
    }
    if (cached_has_bits & 0x00000010u) {
      mutable_log_param()->::opencv_caffe::LogParameter::MergeFrom(from.log_param());
    }
    if (cached_has_bits & 0x00000020u) {
      mutable_flatten_param()->::opencv_caffe::FlattenParameter::MergeFrom(from.flatten_param());
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_reduction_param()->::opencv_caffe::ReductionParameter::MergeFrom(from.reduction_param());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_embed_param()->::opencv_caffe::EmbedParameter::MergeFrom(from.embed_param());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      mutable_tile_param()->::opencv_caffe::TileParameter::MergeFrom(from.tile_param());
    }
    if (cached_has_bits & 0x00000200u) {
      mutable_batch_norm_param()->::opencv_caffe::BatchNormParameter::MergeFrom(from.batch_norm_param());
    }
    if (cached_has_bits & 0x00000400u) {
      mutable_elu_param()->::opencv_caffe::ELUParameter::MergeFrom(from.elu_param());
    }
    if (cached_has_bits & 0x00000800u) {
      mutable_bias_param()->::opencv_caffe::BiasParameter::MergeFrom(from.bias_param());
    }
    if (cached_has_bits & 0x00001000u) {
      mutable_scale_param()->::opencv_caffe::ScaleParameter::MergeFrom(from.scale_param());
    }
    if (cached_has_bits & 0x00002000u) {
      mutable_input_param()->::opencv_caffe::InputParameter::MergeFrom(from.input_param());
    }
    if (cached_has_bits & 0x00004000u) {
      mutable_crop_param()->::opencv_caffe::CropParameter::MergeFrom(from.crop_param());
    }
    if (cached_has_bits & 0x00008000u) {
      mutable_parameter_param()->::opencv_caffe::ParameterParameter::MergeFrom(from.parameter_param());
    }
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      mutable_recurrent_param()->::opencv_caffe::RecurrentParameter::MergeFrom(from.recurrent_param());
    }
    if (cached_has_bits & 0x00020000u) {
      mutable_detection_output_param()->::opencv_caffe::DetectionOutputParameter::MergeFrom(from.detection_output_param());
    }
    if (cached_has_bits & 0x00040000u) {
      mutable_permute_param()->::opencv_caffe::PermuteParameter::MergeFrom(from.permute_param());
    }
    if (cached_has_bits & 0x00080000u) {
      mutable_norm_param()->::opencv_caffe::NormalizeBBoxParameter::MergeFrom(from.norm_param());
    }
    if (cached_has_bits & 0x00100000u) {
      mutable_prior_box_param()->::opencv_caffe::PriorBoxParameter::MergeFrom(from.prior_box_param());
    }
    if (cached_has_bits & 0x00200000u) {
      mutable_proposal_param()->::opencv_caffe::ProposalParameter::MergeFrom(from.proposal_param());
    }
    if (cached_has_bits & 0x00400000u) {
      mutable_psroi_pooling_param()->::opencv_caffe::PSROIPoolingParameter::MergeFrom(from.psroi_pooling_param());
    }
    if (cached_has_bits & 0x00800000u) {
      mutable_roi_pooling_param()->::opencv_caffe::ROIPoolingParameter::MergeFrom(from.roi_pooling_param());
    }
  }
  if (cached_has_bits & 0x01000000u) {
    set_phase(from.phase());
  }
}

void LayerParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.LayerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LayerParameter::CopyFrom(const LayerParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LayerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LayerParameter::IsInitialized() const {
  if (has_psroi_pooling_param()) {
    if (!this->psroi_pooling_param_->IsInitialized()) return false;
  }
  return true;
}

void LayerParameter::Swap(LayerParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LayerParameter::InternalSwap(LayerParameter* other) {
  using std::swap;
  bottom_.InternalSwap(&other->bottom_);
  top_.InternalSwap(&other->top_);
  loss_weight_.InternalSwap(&other->loss_weight_);
  param_.InternalSwap(&other->param_);
  blobs_.InternalSwap(&other->blobs_);
  include_.InternalSwap(&other->include_);
  exclude_.InternalSwap(&other->exclude_);
  propagate_down_.InternalSwap(&other->propagate_down_);
  name_.Swap(&other->name_);
  type_.Swap(&other->type_);
  swap(transform_param_, other->transform_param_);
  swap(loss_param_, other->loss_param_);
  swap(accuracy_param_, other->accuracy_param_);
  swap(argmax_param_, other->argmax_param_);
  swap(concat_param_, other->concat_param_);
  swap(contrastive_loss_param_, other->contrastive_loss_param_);
  swap(convolution_param_, other->convolution_param_);
  swap(data_param_, other->data_param_);
  swap(dropout_param_, other->dropout_param_);
  swap(dummy_data_param_, other->dummy_data_param_);
  swap(eltwise_param_, other->eltwise_param_);
  swap(exp_param_, other->exp_param_);
  swap(hdf5_data_param_, other->hdf5_data_param_);
  swap(hdf5_output_param_, other->hdf5_output_param_);
  swap(hinge_loss_param_, other->hinge_loss_param_);
  swap(image_data_param_, other->image_data_param_);
  swap(infogain_loss_param_, other->infogain_loss_param_);
  swap(inner_product_param_, other->inner_product_param_);
  swap(lrn_param_, other->lrn_param_);
  swap(memory_data_param_, other->memory_data_param_);
  swap(mvn_param_, other->mvn_param_);
  swap(pooling_param_, other->pooling_param_);
  swap(power_param_, other->power_param_);
  swap(relu_param_, other->relu_param_);
  swap(sigmoid_param_, other->sigmoid_param_);
  swap(softmax_param_, other->softmax_param_);
  swap(slice_param_, other->slice_param_);
  swap(tanh_param_, other->tanh_param_);
  swap(threshold_param_, other->threshold_param_);
  swap(window_data_param_, other->window_data_param_);
  swap(python_param_, other->python_param_);
  swap(prelu_param_, other->prelu_param_);
  swap(spp_param_, other->spp_param_);
  swap(reshape_param_, other->reshape_param_);
  swap(log_param_, other->log_param_);
  swap(flatten_param_, other->flatten_param_);
  swap(reduction_param_, other->reduction_param_);
  swap(embed_param_, other->embed_param_);
  swap(tile_param_, other->tile_param_);
  swap(batch_norm_param_, other->batch_norm_param_);
  swap(elu_param_, other->elu_param_);
  swap(bias_param_, other->bias_param_);
  swap(scale_param_, other->scale_param_);
  swap(input_param_, other->input_param_);
  swap(crop_param_, other->crop_param_);
  swap(parameter_param_, other->parameter_param_);
  swap(recurrent_param_, other->recurrent_param_);
  swap(detection_output_param_, other->detection_output_param_);
  swap(permute_param_, other->permute_param_);
  swap(norm_param_, other->norm_param_);
  swap(prior_box_param_, other->prior_box_param_);
  swap(proposal_param_, other->proposal_param_);
  swap(psroi_pooling_param_, other->psroi_pooling_param_);
  swap(roi_pooling_param_, other->roi_pooling_param_);
  swap(phase_, other->phase_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata LayerParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TransformationParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TransformationParameter::kScaleFieldNumber;
const int TransformationParameter::kMirrorFieldNumber;
const int TransformationParameter::kCropSizeFieldNumber;
const int TransformationParameter::kMeanFileFieldNumber;
const int TransformationParameter::kMeanValueFieldNumber;
const int TransformationParameter::kForceColorFieldNumber;
const int TransformationParameter::kForceGrayFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TransformationParameter::TransformationParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTransformationParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.TransformationParameter)
}
TransformationParameter::TransformationParameter(const TransformationParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      mean_value_(from.mean_value_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_mean_file()) {
    mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
  }
  ::memcpy(&crop_size_, &from.crop_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&crop_size_)) + sizeof(scale_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.TransformationParameter)
}

void TransformationParameter::SharedCtor() {
  _cached_size_ = 0;
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&crop_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&force_gray_) -
      reinterpret_cast<char*>(&crop_size_)) + sizeof(force_gray_));
  scale_ = 1;
}

TransformationParameter::~TransformationParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.TransformationParameter)
  SharedDtor();
}

void TransformationParameter::SharedDtor() {
  mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void TransformationParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TransformationParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TransformationParameter& TransformationParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTransformationParameter();
  return *internal_default_instance();
}

TransformationParameter* TransformationParameter::New(::google::protobuf::Arena* arena) const {
  TransformationParameter* n = new TransformationParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TransformationParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.TransformationParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  mean_value_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!mean_file_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*mean_file_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 62u) {
    ::memset(&crop_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&force_gray_) -
        reinterpret_cast<char*>(&crop_size_)) + sizeof(force_gray_));
    scale_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TransformationParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.TransformationParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float scale = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool mirror = 2 [default = false];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_mirror();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &mirror_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 crop_size = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_crop_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &crop_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string mean_file = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_mean_file()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->mean_file().data(), static_cast<int>(this->mean_file().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.TransformationParameter.mean_file");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float mean_value = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 45u, input, this->mutable_mean_value())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_mean_value())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool force_color = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_force_color();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &force_color_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool force_gray = 7 [default = false];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_force_gray();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &force_gray_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.TransformationParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.TransformationParameter)
  return false;
#undef DO_
}

void TransformationParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.TransformationParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float scale = 1 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->scale(), output);
  }

  // optional bool mirror = 2 [default = false];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->mirror(), output);
  }

  // optional uint32 crop_size = 3 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->crop_size(), output);
  }

  // optional string mean_file = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.TransformationParameter.mean_file");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->mean_file(), output);
  }

  // repeated float mean_value = 5;
  for (int i = 0, n = this->mean_value_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      5, this->mean_value(i), output);
  }

  // optional bool force_color = 6 [default = false];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->force_color(), output);
  }

  // optional bool force_gray = 7 [default = false];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->force_gray(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.TransformationParameter)
}

::google::protobuf::uint8* TransformationParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TransformationParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float scale = 1 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->scale(), target);
  }

  // optional bool mirror = 2 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->mirror(), target);
  }

  // optional uint32 crop_size = 3 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->crop_size(), target);
  }

  // optional string mean_file = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.TransformationParameter.mean_file");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->mean_file(), target);
  }

  // repeated float mean_value = 5;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(5, this->mean_value_, target);

  // optional bool force_color = 6 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->force_color(), target);
  }

  // optional bool force_gray = 7 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->force_gray(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TransformationParameter)
  return target;
}

size_t TransformationParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TransformationParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated float mean_value = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->mean_value_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->mean_value_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 63u) {
    // optional string mean_file = 4;
    if (has_mean_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->mean_file());
    }

    // optional uint32 crop_size = 3 [default = 0];
    if (has_crop_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->crop_size());
    }

    // optional bool mirror = 2 [default = false];
    if (has_mirror()) {
      total_size += 1 + 1;
    }

    // optional bool force_color = 6 [default = false];
    if (has_force_color()) {
      total_size += 1 + 1;
    }

    // optional bool force_gray = 7 [default = false];
    if (has_force_gray()) {
      total_size += 1 + 1;
    }

    // optional float scale = 1 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TransformationParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.TransformationParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const TransformationParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TransformationParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.TransformationParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.TransformationParameter)
    MergeFrom(*source);
  }
}

void TransformationParameter::MergeFrom(const TransformationParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TransformationParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  mean_value_.MergeFrom(from.mean_value_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_mean_file();
      mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
    }
    if (cached_has_bits & 0x00000002u) {
      crop_size_ = from.crop_size_;
    }
    if (cached_has_bits & 0x00000004u) {
      mirror_ = from.mirror_;
    }
    if (cached_has_bits & 0x00000008u) {
      force_color_ = from.force_color_;
    }
    if (cached_has_bits & 0x00000010u) {
      force_gray_ = from.force_gray_;
    }
    if (cached_has_bits & 0x00000020u) {
      scale_ = from.scale_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void TransformationParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.TransformationParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TransformationParameter::CopyFrom(const TransformationParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TransformationParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TransformationParameter::IsInitialized() const {
  return true;
}

void TransformationParameter::Swap(TransformationParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TransformationParameter::InternalSwap(TransformationParameter* other) {
  using std::swap;
  mean_value_.InternalSwap(&other->mean_value_);
  mean_file_.Swap(&other->mean_file_);
  swap(crop_size_, other->crop_size_);
  swap(mirror_, other->mirror_);
  swap(force_color_, other->force_color_);
  swap(force_gray_, other->force_gray_);
  swap(scale_, other->scale_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TransformationParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void LossParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int LossParameter::kIgnoreLabelFieldNumber;
const int LossParameter::kNormalizationFieldNumber;
const int LossParameter::kNormalizeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

LossParameter::LossParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLossParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.LossParameter)
}
LossParameter::LossParameter(const LossParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ignore_label_, &from.ignore_label_,
    static_cast<size_t>(reinterpret_cast<char*>(&normalization_) -
    reinterpret_cast<char*>(&ignore_label_)) + sizeof(normalization_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.LossParameter)
}

void LossParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&ignore_label_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&normalize_) -
      reinterpret_cast<char*>(&ignore_label_)) + sizeof(normalize_));
  normalization_ = 1;
}

LossParameter::~LossParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.LossParameter)
  SharedDtor();
}

void LossParameter::SharedDtor() {
}

void LossParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LossParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const LossParameter& LossParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLossParameter();
  return *internal_default_instance();
}

LossParameter* LossParameter::New(::google::protobuf::Arena* arena) const {
  LossParameter* n = new LossParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void LossParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.LossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ::memset(&ignore_label_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&normalize_) -
        reinterpret_cast<char*>(&ignore_label_)) + sizeof(normalize_));
    normalization_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool LossParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.LossParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 ignore_label = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_ignore_label();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &ignore_label_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool normalize = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_normalize();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &normalize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::LossParameter_NormalizationMode_IsValid(value)) {
            set_normalization(static_cast< ::opencv_caffe::LossParameter_NormalizationMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                3, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.LossParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.LossParameter)
  return false;
#undef DO_
}

void LossParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.LossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 ignore_label = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->ignore_label(), output);
  }

  // optional bool normalize = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->normalize(), output);
  }

  // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->normalization(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.LossParameter)
}

::google::protobuf::uint8* LossParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 ignore_label = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->ignore_label(), target);
  }

  // optional bool normalize = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->normalize(), target);
  }

  // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->normalization(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LossParameter)
  return target;
}

size_t LossParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LossParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional int32 ignore_label = 1;
    if (has_ignore_label()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->ignore_label());
    }

    // optional bool normalize = 2;
    if (has_normalize()) {
      total_size += 1 + 1;
    }

    // optional .opencv_caffe.LossParameter.NormalizationMode normalization = 3 [default = VALID];
    if (has_normalization()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->normalization());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LossParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.LossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const LossParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const LossParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.LossParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.LossParameter)
    MergeFrom(*source);
  }
}

void LossParameter::MergeFrom(const LossParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      ignore_label_ = from.ignore_label_;
    }
    if (cached_has_bits & 0x00000002u) {
      normalize_ = from.normalize_;
    }
    if (cached_has_bits & 0x00000004u) {
      normalization_ = from.normalization_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LossParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.LossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LossParameter::CopyFrom(const LossParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LossParameter::IsInitialized() const {
  return true;
}

void LossParameter::Swap(LossParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LossParameter::InternalSwap(LossParameter* other) {
  using std::swap;
  swap(ignore_label_, other->ignore_label_);
  swap(normalize_, other->normalize_);
  swap(normalization_, other->normalization_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata LossParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void AccuracyParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int AccuracyParameter::kTopKFieldNumber;
const int AccuracyParameter::kAxisFieldNumber;
const int AccuracyParameter::kIgnoreLabelFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

AccuracyParameter::AccuracyParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsAccuracyParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.AccuracyParameter)
}
AccuracyParameter::AccuracyParameter(const AccuracyParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ignore_label_, &from.ignore_label_,
    static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
    reinterpret_cast<char*>(&ignore_label_)) + sizeof(axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.AccuracyParameter)
}

void AccuracyParameter::SharedCtor() {
  _cached_size_ = 0;
  ignore_label_ = 0;
  top_k_ = 1u;
  axis_ = 1;
}

AccuracyParameter::~AccuracyParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.AccuracyParameter)
  SharedDtor();
}

void AccuracyParameter::SharedDtor() {
}

void AccuracyParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* AccuracyParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const AccuracyParameter& AccuracyParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsAccuracyParameter();
  return *internal_default_instance();
}

AccuracyParameter* AccuracyParameter::New(::google::protobuf::Arena* arena) const {
  AccuracyParameter* n = new AccuracyParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void AccuracyParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.AccuracyParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ignore_label_ = 0;
    top_k_ = 1u;
    axis_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool AccuracyParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.AccuracyParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 top_k = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_top_k();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &top_k_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 ignore_label = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_ignore_label();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &ignore_label_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.AccuracyParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.AccuracyParameter)
  return false;
#undef DO_
}

void AccuracyParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.AccuracyParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 top_k = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->top_k(), output);
  }

  // optional int32 axis = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output);
  }

  // optional int32 ignore_label = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->ignore_label(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.AccuracyParameter)
}

::google::protobuf::uint8* AccuracyParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.AccuracyParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 top_k = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->top_k(), target);
  }

  // optional int32 axis = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target);
  }

  // optional int32 ignore_label = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->ignore_label(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.AccuracyParameter)
  return target;
}

size_t AccuracyParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.AccuracyParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional int32 ignore_label = 3;
    if (has_ignore_label()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->ignore_label());
    }

    // optional uint32 top_k = 1 [default = 1];
    if (has_top_k()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->top_k());
    }

    // optional int32 axis = 2 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AccuracyParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.AccuracyParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const AccuracyParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const AccuracyParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.AccuracyParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.AccuracyParameter)
    MergeFrom(*source);
  }
}

void AccuracyParameter::MergeFrom(const AccuracyParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.AccuracyParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      ignore_label_ = from.ignore_label_;
    }
    if (cached_has_bits & 0x00000002u) {
      top_k_ = from.top_k_;
    }
    if (cached_has_bits & 0x00000004u) {
      axis_ = from.axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void AccuracyParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.AccuracyParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void AccuracyParameter::CopyFrom(const AccuracyParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.AccuracyParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AccuracyParameter::IsInitialized() const {
  return true;
}

void AccuracyParameter::Swap(AccuracyParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AccuracyParameter::InternalSwap(AccuracyParameter* other) {
  using std::swap;
  swap(ignore_label_, other->ignore_label_);
  swap(top_k_, other->top_k_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata AccuracyParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ArgMaxParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ArgMaxParameter::kOutMaxValFieldNumber;
const int ArgMaxParameter::kTopKFieldNumber;
const int ArgMaxParameter::kAxisFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ArgMaxParameter::ArgMaxParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsArgMaxParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ArgMaxParameter)
}
ArgMaxParameter::ArgMaxParameter(const ArgMaxParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&out_max_val_, &from.out_max_val_,
    static_cast<size_t>(reinterpret_cast<char*>(&top_k_) -
    reinterpret_cast<char*>(&out_max_val_)) + sizeof(top_k_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ArgMaxParameter)
}

void ArgMaxParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&out_max_val_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&axis_) -
      reinterpret_cast<char*>(&out_max_val_)) + sizeof(axis_));
  top_k_ = 1u;
}

ArgMaxParameter::~ArgMaxParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ArgMaxParameter)
  SharedDtor();
}

void ArgMaxParameter::SharedDtor() {
}

void ArgMaxParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ArgMaxParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ArgMaxParameter& ArgMaxParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsArgMaxParameter();
  return *internal_default_instance();
}

ArgMaxParameter* ArgMaxParameter::New(::google::protobuf::Arena* arena) const {
  ArgMaxParameter* n = new ArgMaxParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ArgMaxParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ArgMaxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ::memset(&out_max_val_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&axis_) -
        reinterpret_cast<char*>(&out_max_val_)) + sizeof(axis_));
    top_k_ = 1u;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ArgMaxParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ArgMaxParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool out_max_val = 1 [default = false];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_out_max_val();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &out_max_val_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 top_k = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_top_k();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &top_k_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ArgMaxParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ArgMaxParameter)
  return false;
#undef DO_
}

void ArgMaxParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ArgMaxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool out_max_val = 1 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->out_max_val(), output);
  }

  // optional uint32 top_k = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->top_k(), output);
  }

  // optional int32 axis = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->axis(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ArgMaxParameter)
}

::google::protobuf::uint8* ArgMaxParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ArgMaxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool out_max_val = 1 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->out_max_val(), target);
  }

  // optional uint32 top_k = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->top_k(), target);
  }

  // optional int32 axis = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->axis(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ArgMaxParameter)
  return target;
}

size_t ArgMaxParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ArgMaxParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional bool out_max_val = 1 [default = false];
    if (has_out_max_val()) {
      total_size += 1 + 1;
    }

    // optional int32 axis = 3;
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional uint32 top_k = 2 [default = 1];
    if (has_top_k()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->top_k());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ArgMaxParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ArgMaxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ArgMaxParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ArgMaxParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ArgMaxParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ArgMaxParameter)
    MergeFrom(*source);
  }
}

void ArgMaxParameter::MergeFrom(const ArgMaxParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ArgMaxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      out_max_val_ = from.out_max_val_;
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00000004u) {
      top_k_ = from.top_k_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ArgMaxParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ArgMaxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ArgMaxParameter::CopyFrom(const ArgMaxParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ArgMaxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ArgMaxParameter::IsInitialized() const {
  return true;
}

void ArgMaxParameter::Swap(ArgMaxParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ArgMaxParameter::InternalSwap(ArgMaxParameter* other) {
  using std::swap;
  swap(out_max_val_, other->out_max_val_);
  swap(axis_, other->axis_);
  swap(top_k_, other->top_k_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ArgMaxParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ConcatParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ConcatParameter::kAxisFieldNumber;
const int ConcatParameter::kConcatDimFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ConcatParameter::ConcatParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsConcatParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ConcatParameter)
}
ConcatParameter::ConcatParameter(const ConcatParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&concat_dim_, &from.concat_dim_,
    static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
    reinterpret_cast<char*>(&concat_dim_)) + sizeof(axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConcatParameter)
}

void ConcatParameter::SharedCtor() {
  _cached_size_ = 0;
  concat_dim_ = 1u;
  axis_ = 1;
}

ConcatParameter::~ConcatParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ConcatParameter)
  SharedDtor();
}

void ConcatParameter::SharedDtor() {
}

void ConcatParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ConcatParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ConcatParameter& ConcatParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsConcatParameter();
  return *internal_default_instance();
}

ConcatParameter* ConcatParameter::New(::google::protobuf::Arena* arena) const {
  ConcatParameter* n = new ConcatParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ConcatParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ConcatParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    concat_dim_ = 1u;
    axis_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ConcatParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ConcatParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 concat_dim = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_concat_dim();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &concat_dim_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ConcatParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ConcatParameter)
  return false;
#undef DO_
}

void ConcatParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ConcatParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 concat_dim = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->concat_dim(), output);
  }

  // optional int32 axis = 2 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ConcatParameter)
}

::google::protobuf::uint8* ConcatParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ConcatParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 concat_dim = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->concat_dim(), target);
  }

  // optional int32 axis = 2 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ConcatParameter)
  return target;
}

size_t ConcatParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ConcatParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional uint32 concat_dim = 1 [default = 1];
    if (has_concat_dim()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->concat_dim());
    }

    // optional int32 axis = 2 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ConcatParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ConcatParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ConcatParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ConcatParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ConcatParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ConcatParameter)
    MergeFrom(*source);
  }
}

void ConcatParameter::MergeFrom(const ConcatParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ConcatParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      concat_dim_ = from.concat_dim_;
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ConcatParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ConcatParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ConcatParameter::CopyFrom(const ConcatParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ConcatParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ConcatParameter::IsInitialized() const {
  return true;
}

void ConcatParameter::Swap(ConcatParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ConcatParameter::InternalSwap(ConcatParameter* other) {
  using std::swap;
  swap(concat_dim_, other->concat_dim_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ConcatParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void BatchNormParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BatchNormParameter::kUseGlobalStatsFieldNumber;
const int BatchNormParameter::kMovingAverageFractionFieldNumber;
const int BatchNormParameter::kEpsFieldNumber;
const int BatchNormParameter::kScaleBiasFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BatchNormParameter::BatchNormParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBatchNormParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.BatchNormParameter)
}
BatchNormParameter::BatchNormParameter(const BatchNormParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&use_global_stats_, &from.use_global_stats_,
    static_cast<size_t>(reinterpret_cast<char*>(&eps_) -
    reinterpret_cast<char*>(&use_global_stats_)) + sizeof(eps_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.BatchNormParameter)
}

void BatchNormParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&use_global_stats_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&scale_bias_) -
      reinterpret_cast<char*>(&use_global_stats_)) + sizeof(scale_bias_));
  moving_average_fraction_ = 0.999f;
  eps_ = 1e-05f;
}

BatchNormParameter::~BatchNormParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.BatchNormParameter)
  SharedDtor();
}

void BatchNormParameter::SharedDtor() {
}

void BatchNormParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BatchNormParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const BatchNormParameter& BatchNormParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBatchNormParameter();
  return *internal_default_instance();
}

BatchNormParameter* BatchNormParameter::New(::google::protobuf::Arena* arena) const {
  BatchNormParameter* n = new BatchNormParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BatchNormParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.BatchNormParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&use_global_stats_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&scale_bias_) -
      reinterpret_cast<char*>(&use_global_stats_)) + sizeof(scale_bias_));
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 12u) {
    moving_average_fraction_ = 0.999f;
    eps_ = 1e-05f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BatchNormParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.BatchNormParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool use_global_stats = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_use_global_stats();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &use_global_stats_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float moving_average_fraction = 2 [default = 0.999];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_moving_average_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &moving_average_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float eps = 3 [default = 1e-05];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_eps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &eps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool scale_bias = 7 [default = false];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_scale_bias();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &scale_bias_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.BatchNormParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.BatchNormParameter)
  return false;
#undef DO_
}

void BatchNormParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.BatchNormParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool use_global_stats = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->use_global_stats(), output);
  }

  // optional float moving_average_fraction = 2 [default = 0.999];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->moving_average_fraction(), output);
  }

  // optional float eps = 3 [default = 1e-05];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->eps(), output);
  }

  // optional bool scale_bias = 7 [default = false];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->scale_bias(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.BatchNormParameter)
}

::google::protobuf::uint8* BatchNormParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BatchNormParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool use_global_stats = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->use_global_stats(), target);
  }

  // optional float moving_average_fraction = 2 [default = 0.999];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->moving_average_fraction(), target);
  }

  // optional float eps = 3 [default = 1e-05];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->eps(), target);
  }

  // optional bool scale_bias = 7 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->scale_bias(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BatchNormParameter)
  return target;
}

size_t BatchNormParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BatchNormParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional bool use_global_stats = 1;
    if (has_use_global_stats()) {
      total_size += 1 + 1;
    }

    // optional bool scale_bias = 7 [default = false];
    if (has_scale_bias()) {
      total_size += 1 + 1;
    }

    // optional float moving_average_fraction = 2 [default = 0.999];
    if (has_moving_average_fraction()) {
      total_size += 1 + 4;
    }

    // optional float eps = 3 [default = 1e-05];
    if (has_eps()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BatchNormParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.BatchNormParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const BatchNormParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const BatchNormParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.BatchNormParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.BatchNormParameter)
    MergeFrom(*source);
  }
}

void BatchNormParameter::MergeFrom(const BatchNormParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BatchNormParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      use_global_stats_ = from.use_global_stats_;
    }
    if (cached_has_bits & 0x00000002u) {
      scale_bias_ = from.scale_bias_;
    }
    if (cached_has_bits & 0x00000004u) {
      moving_average_fraction_ = from.moving_average_fraction_;
    }
    if (cached_has_bits & 0x00000008u) {
      eps_ = from.eps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void BatchNormParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.BatchNormParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BatchNormParameter::CopyFrom(const BatchNormParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BatchNormParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BatchNormParameter::IsInitialized() const {
  return true;
}

void BatchNormParameter::Swap(BatchNormParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BatchNormParameter::InternalSwap(BatchNormParameter* other) {
  using std::swap;
  swap(use_global_stats_, other->use_global_stats_);
  swap(scale_bias_, other->scale_bias_);
  swap(moving_average_fraction_, other->moving_average_fraction_);
  swap(eps_, other->eps_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata BatchNormParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void BiasParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_BiasParameter_default_instance_._instance.get_mutable()->filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BiasParameter::kAxisFieldNumber;
const int BiasParameter::kNumAxesFieldNumber;
const int BiasParameter::kFillerFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BiasParameter::BiasParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBiasParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.BiasParameter)
}
BiasParameter::BiasParameter(const BiasParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_filler()) {
    filler_ = new ::opencv_caffe::FillerParameter(*from.filler_);
  } else {
    filler_ = NULL;
  }
  ::memcpy(&axis_, &from.axis_,
    static_cast<size_t>(reinterpret_cast<char*>(&num_axes_) -
    reinterpret_cast<char*>(&axis_)) + sizeof(num_axes_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.BiasParameter)
}

void BiasParameter::SharedCtor() {
  _cached_size_ = 0;
  filler_ = NULL;
  axis_ = 1;
  num_axes_ = 1;
}

BiasParameter::~BiasParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.BiasParameter)
  SharedDtor();
}

void BiasParameter::SharedDtor() {
  if (this != internal_default_instance()) delete filler_;
}

void BiasParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BiasParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const BiasParameter& BiasParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsBiasParameter();
  return *internal_default_instance();
}

BiasParameter* BiasParameter::New(::google::protobuf::Arena* arena) const {
  BiasParameter* n = new BiasParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BiasParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.BiasParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(filler_ != NULL);
      filler_->Clear();
    }
    axis_ = 1;
    num_axes_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BiasParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.BiasParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 axis = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 num_axes = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_num_axes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_axes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter filler = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.BiasParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.BiasParameter)
  return false;
#undef DO_
}

void BiasParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.BiasParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output);
  }

  // optional int32 num_axes = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_axes(), output);
  }

  // optional .opencv_caffe.FillerParameter filler = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->filler_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.BiasParameter)
}

::google::protobuf::uint8* BiasParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.BiasParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target);
  }

  // optional int32 num_axes = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_axes(), target);
  }

  // optional .opencv_caffe.FillerParameter filler = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, *this->filler_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.BiasParameter)
  return target;
}

size_t BiasParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.BiasParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional .opencv_caffe.FillerParameter filler = 3;
    if (has_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->filler_);
    }

    // optional int32 axis = 1 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional int32 num_axes = 2 [default = 1];
    if (has_num_axes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->num_axes());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BiasParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.BiasParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const BiasParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const BiasParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.BiasParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.BiasParameter)
    MergeFrom(*source);
  }
}

void BiasParameter::MergeFrom(const BiasParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.BiasParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.filler());
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00000004u) {
      num_axes_ = from.num_axes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void BiasParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.BiasParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BiasParameter::CopyFrom(const BiasParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.BiasParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BiasParameter::IsInitialized() const {
  return true;
}

void BiasParameter::Swap(BiasParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BiasParameter::InternalSwap(BiasParameter* other) {
  using std::swap;
  swap(filler_, other->filler_);
  swap(axis_, other->axis_);
  swap(num_axes_, other->num_axes_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata BiasParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ContrastiveLossParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ContrastiveLossParameter::kMarginFieldNumber;
const int ContrastiveLossParameter::kLegacyVersionFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ContrastiveLossParameter::ContrastiveLossParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsContrastiveLossParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ContrastiveLossParameter)
}
ContrastiveLossParameter::ContrastiveLossParameter(const ContrastiveLossParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&legacy_version_, &from.legacy_version_,
    static_cast<size_t>(reinterpret_cast<char*>(&margin_) -
    reinterpret_cast<char*>(&legacy_version_)) + sizeof(margin_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ContrastiveLossParameter)
}

void ContrastiveLossParameter::SharedCtor() {
  _cached_size_ = 0;
  legacy_version_ = false;
  margin_ = 1;
}

ContrastiveLossParameter::~ContrastiveLossParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ContrastiveLossParameter)
  SharedDtor();
}

void ContrastiveLossParameter::SharedDtor() {
}

void ContrastiveLossParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ContrastiveLossParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ContrastiveLossParameter& ContrastiveLossParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsContrastiveLossParameter();
  return *internal_default_instance();
}

ContrastiveLossParameter* ContrastiveLossParameter::New(::google::protobuf::Arena* arena) const {
  ContrastiveLossParameter* n = new ContrastiveLossParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ContrastiveLossParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ContrastiveLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    legacy_version_ = false;
    margin_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ContrastiveLossParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ContrastiveLossParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float margin = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_margin();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &margin_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool legacy_version = 2 [default = false];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_legacy_version();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &legacy_version_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ContrastiveLossParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ContrastiveLossParameter)
  return false;
#undef DO_
}

void ContrastiveLossParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ContrastiveLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float margin = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->margin(), output);
  }

  // optional bool legacy_version = 2 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->legacy_version(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ContrastiveLossParameter)
}

::google::protobuf::uint8* ContrastiveLossParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ContrastiveLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float margin = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->margin(), target);
  }

  // optional bool legacy_version = 2 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->legacy_version(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ContrastiveLossParameter)
  return target;
}

size_t ContrastiveLossParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ContrastiveLossParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bool legacy_version = 2 [default = false];
    if (has_legacy_version()) {
      total_size += 1 + 1;
    }

    // optional float margin = 1 [default = 1];
    if (has_margin()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ContrastiveLossParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ContrastiveLossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ContrastiveLossParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ContrastiveLossParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ContrastiveLossParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ContrastiveLossParameter)
    MergeFrom(*source);
  }
}

void ContrastiveLossParameter::MergeFrom(const ContrastiveLossParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ContrastiveLossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      legacy_version_ = from.legacy_version_;
    }
    if (cached_has_bits & 0x00000002u) {
      margin_ = from.margin_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ContrastiveLossParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ContrastiveLossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ContrastiveLossParameter::CopyFrom(const ContrastiveLossParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ContrastiveLossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ContrastiveLossParameter::IsInitialized() const {
  return true;
}

void ContrastiveLossParameter::Swap(ContrastiveLossParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ContrastiveLossParameter::InternalSwap(ContrastiveLossParameter* other) {
  using std::swap;
  swap(legacy_version_, other->legacy_version_);
  swap(margin_, other->margin_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ContrastiveLossParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ConvolutionParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_ConvolutionParameter_default_instance_._instance.get_mutable()->weight_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_ConvolutionParameter_default_instance_._instance.get_mutable()->bias_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ConvolutionParameter::kNumOutputFieldNumber;
const int ConvolutionParameter::kBiasTermFieldNumber;
const int ConvolutionParameter::kPadFieldNumber;
const int ConvolutionParameter::kKernelSizeFieldNumber;
const int ConvolutionParameter::kStrideFieldNumber;
const int ConvolutionParameter::kDilationFieldNumber;
const int ConvolutionParameter::kPadHFieldNumber;
const int ConvolutionParameter::kPadWFieldNumber;
const int ConvolutionParameter::kKernelHFieldNumber;
const int ConvolutionParameter::kKernelWFieldNumber;
const int ConvolutionParameter::kStrideHFieldNumber;
const int ConvolutionParameter::kStrideWFieldNumber;
const int ConvolutionParameter::kGroupFieldNumber;
const int ConvolutionParameter::kWeightFillerFieldNumber;
const int ConvolutionParameter::kBiasFillerFieldNumber;
const int ConvolutionParameter::kEngineFieldNumber;
const int ConvolutionParameter::kAxisFieldNumber;
const int ConvolutionParameter::kForceNdIm2ColFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ConvolutionParameter::ConvolutionParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsConvolutionParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ConvolutionParameter)
}
ConvolutionParameter::ConvolutionParameter(const ConvolutionParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      pad_(from.pad_),
      kernel_size_(from.kernel_size_),
      stride_(from.stride_),
      dilation_(from.dilation_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_weight_filler()) {
    weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_);
  } else {
    weight_filler_ = NULL;
  }
  if (from.has_bias_filler()) {
    bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_);
  } else {
    bias_filler_ = NULL;
  }
  ::memcpy(&num_output_, &from.num_output_,
    static_cast<size_t>(reinterpret_cast<char*>(&group_) -
    reinterpret_cast<char*>(&num_output_)) + sizeof(group_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ConvolutionParameter)
}

void ConvolutionParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&weight_filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&force_nd_im2col_) -
      reinterpret_cast<char*>(&weight_filler_)) + sizeof(force_nd_im2col_));
  axis_ = 1;
  bias_term_ = true;
  group_ = 1u;
}

ConvolutionParameter::~ConvolutionParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ConvolutionParameter)
  SharedDtor();
}

void ConvolutionParameter::SharedDtor() {
  if (this != internal_default_instance()) delete weight_filler_;
  if (this != internal_default_instance()) delete bias_filler_;
}

void ConvolutionParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ConvolutionParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ConvolutionParameter& ConvolutionParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsConvolutionParameter();
  return *internal_default_instance();
}

ConvolutionParameter* ConvolutionParameter::New(::google::protobuf::Arena* arena) const {
  ConvolutionParameter* n = new ConvolutionParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ConvolutionParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ConvolutionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  pad_.Clear();
  kernel_size_.Clear();
  stride_.Clear();
  dilation_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(weight_filler_ != NULL);
      weight_filler_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(bias_filler_ != NULL);
      bias_filler_->Clear();
    }
  }
  if (cached_has_bits & 252u) {
    ::memset(&num_output_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&stride_h_) -
        reinterpret_cast<char*>(&num_output_)) + sizeof(stride_h_));
  }
  if (cached_has_bits & 16128u) {
    ::memset(&stride_w_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&force_nd_im2col_) -
        reinterpret_cast<char*>(&stride_w_)) + sizeof(force_nd_im2col_));
    axis_ = 1;
    bias_term_ = true;
    group_ = 1u;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ConvolutionParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ConvolutionParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_output = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_num_output();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_output_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool bias_term = 2 [default = true];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_bias_term();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &bias_term_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 pad = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 24u, input, this->mutable_pad())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_pad())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 kernel_size = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 32u, input, this->mutable_kernel_size())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_kernel_size())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 group = 5 [default = 1];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_group();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &group_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 stride = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 48u, input, this->mutable_stride())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_stride())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter weight_filler = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_weight_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter bias_filler = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pad_h = 9 [default = 0];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_pad_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pad_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pad_w = 10 [default = 0];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_pad_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pad_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 kernel_h = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          set_has_kernel_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kernel_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 kernel_w = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) {
          set_has_kernel_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kernel_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 stride_h = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) {
          set_has_stride_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stride_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 stride_w = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) {
          set_has_stride_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stride_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(120u /* 120 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::ConvolutionParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::ConvolutionParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                15, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 16 [default = 1];
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u /* 128 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool force_nd_im2col = 17 [default = false];
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(136u /* 136 & 0xFF */)) {
          set_has_force_nd_im2col();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &force_nd_im2col_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 dilation = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(144u /* 144 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 2, 144u, input, this->mutable_dilation())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 146 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_dilation())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ConvolutionParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ConvolutionParameter)
  return false;
#undef DO_
}

void ConvolutionParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ConvolutionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output);
  }

  // optional bool bias_term = 2 [default = true];
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->bias_term(), output);
  }

  // repeated uint32 pad = 3;
  for (int i = 0, n = this->pad_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      3, this->pad(i), output);
  }

  // repeated uint32 kernel_size = 4;
  for (int i = 0, n = this->kernel_size_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      4, this->kernel_size(i), output);
  }

  // optional uint32 group = 5 [default = 1];
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->group(), output);
  }

  // repeated uint32 stride = 6;
  for (int i = 0, n = this->stride_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      6, this->stride(i), output);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 7;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, *this->weight_filler_, output);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 8;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, *this->bias_filler_, output);
  }

  // optional uint32 pad_h = 9 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->pad_h(), output);
  }

  // optional uint32 pad_w = 10 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->pad_w(), output);
  }

  // optional uint32 kernel_h = 11;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->kernel_h(), output);
  }

  // optional uint32 kernel_w = 12;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->kernel_w(), output);
  }

  // optional uint32 stride_h = 13;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->stride_h(), output);
  }

  // optional uint32 stride_w = 14;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(14, this->stride_w(), output);
  }

  // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      15, this->engine(), output);
  }

  // optional int32 axis = 16 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(16, this->axis(), output);
  }

  // optional bool force_nd_im2col = 17 [default = false];
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->force_nd_im2col(), output);
  }

  // repeated uint32 dilation = 18;
  for (int i = 0, n = this->dilation_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      18, this->dilation(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ConvolutionParameter)
}

::google::protobuf::uint8* ConvolutionParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ConvolutionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target);
  }

  // optional bool bias_term = 2 [default = true];
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->bias_term(), target);
  }

  // repeated uint32 pad = 3;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(3, this->pad_, target);

  // repeated uint32 kernel_size = 4;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(4, this->kernel_size_, target);

  // optional uint32 group = 5 [default = 1];
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->group(), target);
  }

  // repeated uint32 stride = 6;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(6, this->stride_, target);

  // optional .opencv_caffe.FillerParameter weight_filler = 7;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        7, *this->weight_filler_, deterministic, target);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 8;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, *this->bias_filler_, deterministic, target);
  }

  // optional uint32 pad_h = 9 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->pad_h(), target);
  }

  // optional uint32 pad_w = 10 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->pad_w(), target);
  }

  // optional uint32 kernel_h = 11;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->kernel_h(), target);
  }

  // optional uint32 kernel_w = 12;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(12, this->kernel_w(), target);
  }

  // optional uint32 stride_h = 13;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->stride_h(), target);
  }

  // optional uint32 stride_w = 14;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(14, this->stride_w(), target);
  }

  // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      15, this->engine(), target);
  }

  // optional int32 axis = 16 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(16, this->axis(), target);
  }

  // optional bool force_nd_im2col = 17 [default = false];
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->force_nd_im2col(), target);
  }

  // repeated uint32 dilation = 18;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(18, this->dilation_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ConvolutionParameter)
  return target;
}

size_t ConvolutionParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ConvolutionParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated uint32 pad = 3;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->pad_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->pad_size());
    total_size += data_size;
  }

  // repeated uint32 kernel_size = 4;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->kernel_size_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->kernel_size_size());
    total_size += data_size;
  }

  // repeated uint32 stride = 6;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->stride_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->stride_size());
    total_size += data_size;
  }

  // repeated uint32 dilation = 18;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->dilation_);
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->dilation_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional .opencv_caffe.FillerParameter weight_filler = 7;
    if (has_weight_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->weight_filler_);
    }

    // optional .opencv_caffe.FillerParameter bias_filler = 8;
    if (has_bias_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_filler_);
    }

    // optional uint32 num_output = 1;
    if (has_num_output()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_output());
    }

    // optional uint32 pad_h = 9 [default = 0];
    if (has_pad_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pad_h());
    }

    // optional uint32 pad_w = 10 [default = 0];
    if (has_pad_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pad_w());
    }

    // optional uint32 kernel_h = 11;
    if (has_kernel_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kernel_h());
    }

    // optional uint32 kernel_w = 12;
    if (has_kernel_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kernel_w());
    }

    // optional uint32 stride_h = 13;
    if (has_stride_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stride_h());
    }

  }
  if (_has_bits_[8 / 32] & 16128u) {
    // optional uint32 stride_w = 14;
    if (has_stride_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stride_w());
    }

    // optional .opencv_caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
    if (has_engine()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
    }

    // optional bool force_nd_im2col = 17 [default = false];
    if (has_force_nd_im2col()) {
      total_size += 2 + 1;
    }

    // optional int32 axis = 16 [default = 1];
    if (has_axis()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional bool bias_term = 2 [default = true];
    if (has_bias_term()) {
      total_size += 1 + 1;
    }

    // optional uint32 group = 5 [default = 1];
    if (has_group()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->group());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ConvolutionParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ConvolutionParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ConvolutionParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ConvolutionParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ConvolutionParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ConvolutionParameter)
    MergeFrom(*source);
  }
}

void ConvolutionParameter::MergeFrom(const ConvolutionParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ConvolutionParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  pad_.MergeFrom(from.pad_);
  kernel_size_.MergeFrom(from.kernel_size_);
  stride_.MergeFrom(from.stride_);
  dilation_.MergeFrom(from.dilation_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.weight_filler());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.bias_filler());
    }
    if (cached_has_bits & 0x00000004u) {
      num_output_ = from.num_output_;
    }
    if (cached_has_bits & 0x00000008u) {
      pad_h_ = from.pad_h_;
    }
    if (cached_has_bits & 0x00000010u) {
      pad_w_ = from.pad_w_;
    }
    if (cached_has_bits & 0x00000020u) {
      kernel_h_ = from.kernel_h_;
    }
    if (cached_has_bits & 0x00000040u) {
      kernel_w_ = from.kernel_w_;
    }
    if (cached_has_bits & 0x00000080u) {
      stride_h_ = from.stride_h_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 16128u) {
    if (cached_has_bits & 0x00000100u) {
      stride_w_ = from.stride_w_;
    }
    if (cached_has_bits & 0x00000200u) {
      engine_ = from.engine_;
    }
    if (cached_has_bits & 0x00000400u) {
      force_nd_im2col_ = from.force_nd_im2col_;
    }
    if (cached_has_bits & 0x00000800u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00001000u) {
      bias_term_ = from.bias_term_;
    }
    if (cached_has_bits & 0x00002000u) {
      group_ = from.group_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ConvolutionParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ConvolutionParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ConvolutionParameter::CopyFrom(const ConvolutionParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ConvolutionParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ConvolutionParameter::IsInitialized() const {
  return true;
}

void ConvolutionParameter::Swap(ConvolutionParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ConvolutionParameter::InternalSwap(ConvolutionParameter* other) {
  using std::swap;
  pad_.InternalSwap(&other->pad_);
  kernel_size_.InternalSwap(&other->kernel_size_);
  stride_.InternalSwap(&other->stride_);
  dilation_.InternalSwap(&other->dilation_);
  swap(weight_filler_, other->weight_filler_);
  swap(bias_filler_, other->bias_filler_);
  swap(num_output_, other->num_output_);
  swap(pad_h_, other->pad_h_);
  swap(pad_w_, other->pad_w_);
  swap(kernel_h_, other->kernel_h_);
  swap(kernel_w_, other->kernel_w_);
  swap(stride_h_, other->stride_h_);
  swap(stride_w_, other->stride_w_);
  swap(engine_, other->engine_);
  swap(force_nd_im2col_, other->force_nd_im2col_);
  swap(axis_, other->axis_);
  swap(bias_term_, other->bias_term_);
  swap(group_, other->group_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ConvolutionParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void CropParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CropParameter::kAxisFieldNumber;
const int CropParameter::kOffsetFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CropParameter::CropParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsCropParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.CropParameter)
}
CropParameter::CropParameter(const CropParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      offset_(from.offset_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  axis_ = from.axis_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.CropParameter)
}

void CropParameter::SharedCtor() {
  _cached_size_ = 0;
  axis_ = 2;
}

CropParameter::~CropParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.CropParameter)
  SharedDtor();
}

void CropParameter::SharedDtor() {
}

void CropParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CropParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const CropParameter& CropParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsCropParameter();
  return *internal_default_instance();
}

CropParameter* CropParameter::New(::google::protobuf::Arena* arena) const {
  CropParameter* n = new CropParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CropParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.CropParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  offset_.Clear();
  axis_ = 2;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CropParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.CropParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 axis = 1 [default = 2];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 offset = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 16u, input, this->mutable_offset())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_offset())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.CropParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.CropParameter)
  return false;
#undef DO_
}

void CropParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.CropParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 2];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output);
  }

  // repeated uint32 offset = 2;
  for (int i = 0, n = this->offset_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      2, this->offset(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.CropParameter)
}

::google::protobuf::uint8* CropParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.CropParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 2];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target);
  }

  // repeated uint32 offset = 2;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(2, this->offset_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.CropParameter)
  return target;
}

size_t CropParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.CropParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated uint32 offset = 2;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->offset_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->offset_size());
    total_size += data_size;
  }

  // optional int32 axis = 1 [default = 2];
  if (has_axis()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->axis());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CropParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.CropParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const CropParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const CropParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.CropParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.CropParameter)
    MergeFrom(*source);
  }
}

void CropParameter::MergeFrom(const CropParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.CropParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  offset_.MergeFrom(from.offset_);
  if (from.has_axis()) {
    set_axis(from.axis());
  }
}

void CropParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.CropParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CropParameter::CopyFrom(const CropParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.CropParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CropParameter::IsInitialized() const {
  return true;
}

void CropParameter::Swap(CropParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CropParameter::InternalSwap(CropParameter* other) {
  using std::swap;
  offset_.InternalSwap(&other->offset_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata CropParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DataParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DataParameter::kSourceFieldNumber;
const int DataParameter::kBatchSizeFieldNumber;
const int DataParameter::kRandSkipFieldNumber;
const int DataParameter::kBackendFieldNumber;
const int DataParameter::kScaleFieldNumber;
const int DataParameter::kMeanFileFieldNumber;
const int DataParameter::kCropSizeFieldNumber;
const int DataParameter::kMirrorFieldNumber;
const int DataParameter::kForceEncodedColorFieldNumber;
const int DataParameter::kPrefetchFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DataParameter::DataParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDataParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.DataParameter)
}
DataParameter::DataParameter(const DataParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_source()) {
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_mean_file()) {
    mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
  }
  ::memcpy(&batch_size_, &from.batch_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&prefetch_) -
    reinterpret_cast<char*>(&batch_size_)) + sizeof(prefetch_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.DataParameter)
}

void DataParameter::SharedCtor() {
  _cached_size_ = 0;
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&batch_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&backend_) -
      reinterpret_cast<char*>(&batch_size_)) + sizeof(backend_));
  scale_ = 1;
  prefetch_ = 4u;
}

DataParameter::~DataParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.DataParameter)
  SharedDtor();
}

void DataParameter::SharedDtor() {
  source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DataParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DataParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DataParameter& DataParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDataParameter();
  return *internal_default_instance();
}

DataParameter* DataParameter::New(::google::protobuf::Arena* arena) const {
  DataParameter* n = new DataParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DataParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.DataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!source_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*source_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!mean_file_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*mean_file_.UnsafeRawStringPointer())->clear();
    }
  }
  if (cached_has_bits & 252u) {
    ::memset(&batch_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&backend_) -
        reinterpret_cast<char*>(&batch_size_)) + sizeof(backend_));
  }
  if (cached_has_bits & 768u) {
    scale_ = 1;
    prefetch_ = 4u;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DataParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.DataParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string source = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source().data(), static_cast<int>(this->source().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.DataParameter.source");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string mean_file = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_mean_file()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->mean_file().data(), static_cast<int>(this->mean_file().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.DataParameter.mean_file");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 batch_size = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_batch_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &batch_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 crop_size = 5 [default = 0];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_crop_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &crop_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool mirror = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_mirror();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &mirror_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 rand_skip = 7 [default = 0];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_rand_skip();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rand_skip_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::DataParameter_DB_IsValid(value)) {
            set_backend(static_cast< ::opencv_caffe::DataParameter_DB >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                8, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool force_encoded_color = 9 [default = false];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_force_encoded_color();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &force_encoded_color_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 prefetch = 10 [default = 4];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_prefetch();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &prefetch_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.DataParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.DataParameter)
  return false;
#undef DO_
}

void DataParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.DataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.DataParameter.source");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->source(), output);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output);
  }

  // optional string mean_file = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.DataParameter.mean_file");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->mean_file(), output);
  }

  // optional uint32 batch_size = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->batch_size(), output);
  }

  // optional uint32 crop_size = 5 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crop_size(), output);
  }

  // optional bool mirror = 6 [default = false];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mirror(), output);
  }

  // optional uint32 rand_skip = 7 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->rand_skip(), output);
  }

  // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->backend(), output);
  }

  // optional bool force_encoded_color = 9 [default = false];
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->force_encoded_color(), output);
  }

  // optional uint32 prefetch = 10 [default = 4];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->prefetch(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.DataParameter)
}

::google::protobuf::uint8* DataParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.DataParameter.source");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->source(), target);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target);
  }

  // optional string mean_file = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.DataParameter.mean_file");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->mean_file(), target);
  }

  // optional uint32 batch_size = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->batch_size(), target);
  }

  // optional uint32 crop_size = 5 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->crop_size(), target);
  }

  // optional bool mirror = 6 [default = false];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->mirror(), target);
  }

  // optional uint32 rand_skip = 7 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->rand_skip(), target);
  }

  // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->backend(), target);
  }

  // optional bool force_encoded_color = 9 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->force_encoded_color(), target);
  }

  // optional uint32 prefetch = 10 [default = 4];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->prefetch(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DataParameter)
  return target;
}

size_t DataParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DataParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional string source = 1;
    if (has_source()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->source());
    }

    // optional string mean_file = 3;
    if (has_mean_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->mean_file());
    }

    // optional uint32 batch_size = 4;
    if (has_batch_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->batch_size());
    }

    // optional uint32 crop_size = 5 [default = 0];
    if (has_crop_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->crop_size());
    }

    // optional uint32 rand_skip = 7 [default = 0];
    if (has_rand_skip()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->rand_skip());
    }

    // optional bool mirror = 6 [default = false];
    if (has_mirror()) {
      total_size += 1 + 1;
    }

    // optional bool force_encoded_color = 9 [default = false];
    if (has_force_encoded_color()) {
      total_size += 1 + 1;
    }

    // optional .opencv_caffe.DataParameter.DB backend = 8 [default = LEVELDB];
    if (has_backend()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->backend());
    }

  }
  if (_has_bits_[8 / 32] & 768u) {
    // optional float scale = 2 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

    // optional uint32 prefetch = 10 [default = 4];
    if (has_prefetch()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->prefetch());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DataParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.DataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const DataParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DataParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.DataParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.DataParameter)
    MergeFrom(*source);
  }
}

void DataParameter::MergeFrom(const DataParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_source();
      source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_mean_file();
      mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
    }
    if (cached_has_bits & 0x00000004u) {
      batch_size_ = from.batch_size_;
    }
    if (cached_has_bits & 0x00000008u) {
      crop_size_ = from.crop_size_;
    }
    if (cached_has_bits & 0x00000010u) {
      rand_skip_ = from.rand_skip_;
    }
    if (cached_has_bits & 0x00000020u) {
      mirror_ = from.mirror_;
    }
    if (cached_has_bits & 0x00000040u) {
      force_encoded_color_ = from.force_encoded_color_;
    }
    if (cached_has_bits & 0x00000080u) {
      backend_ = from.backend_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 768u) {
    if (cached_has_bits & 0x00000100u) {
      scale_ = from.scale_;
    }
    if (cached_has_bits & 0x00000200u) {
      prefetch_ = from.prefetch_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DataParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.DataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DataParameter::CopyFrom(const DataParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DataParameter::IsInitialized() const {
  return true;
}

void DataParameter::Swap(DataParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DataParameter::InternalSwap(DataParameter* other) {
  using std::swap;
  source_.Swap(&other->source_);
  mean_file_.Swap(&other->mean_file_);
  swap(batch_size_, other->batch_size_);
  swap(crop_size_, other->crop_size_);
  swap(rand_skip_, other->rand_skip_);
  swap(mirror_, other->mirror_);
  swap(force_encoded_color_, other->force_encoded_color_);
  swap(backend_, other->backend_);
  swap(scale_, other->scale_);
  swap(prefetch_, other->prefetch_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DataParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void NonMaximumSuppressionParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NonMaximumSuppressionParameter::kNmsThresholdFieldNumber;
const int NonMaximumSuppressionParameter::kTopKFieldNumber;
const int NonMaximumSuppressionParameter::kEtaFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NonMaximumSuppressionParameter::NonMaximumSuppressionParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNonMaximumSuppressionParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.NonMaximumSuppressionParameter)
}
NonMaximumSuppressionParameter::NonMaximumSuppressionParameter(const NonMaximumSuppressionParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&top_k_, &from.top_k_,
    static_cast<size_t>(reinterpret_cast<char*>(&eta_) -
    reinterpret_cast<char*>(&top_k_)) + sizeof(eta_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.NonMaximumSuppressionParameter)
}

void NonMaximumSuppressionParameter::SharedCtor() {
  _cached_size_ = 0;
  top_k_ = 0;
  nms_threshold_ = 0.3f;
  eta_ = 1;
}

NonMaximumSuppressionParameter::~NonMaximumSuppressionParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.NonMaximumSuppressionParameter)
  SharedDtor();
}

void NonMaximumSuppressionParameter::SharedDtor() {
}

void NonMaximumSuppressionParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NonMaximumSuppressionParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const NonMaximumSuppressionParameter& NonMaximumSuppressionParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNonMaximumSuppressionParameter();
  return *internal_default_instance();
}

NonMaximumSuppressionParameter* NonMaximumSuppressionParameter::New(::google::protobuf::Arena* arena) const {
  NonMaximumSuppressionParameter* n = new NonMaximumSuppressionParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NonMaximumSuppressionParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.NonMaximumSuppressionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    top_k_ = 0;
    nms_threshold_ = 0.3f;
    eta_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NonMaximumSuppressionParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.NonMaximumSuppressionParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float nms_threshold = 1 [default = 0.3];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_nms_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &nms_threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 top_k = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_top_k();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &top_k_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float eta = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_eta();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &eta_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.NonMaximumSuppressionParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.NonMaximumSuppressionParameter)
  return false;
#undef DO_
}

void NonMaximumSuppressionParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.NonMaximumSuppressionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float nms_threshold = 1 [default = 0.3];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->nms_threshold(), output);
  }

  // optional int32 top_k = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->top_k(), output);
  }

  // optional float eta = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->eta(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.NonMaximumSuppressionParameter)
}

::google::protobuf::uint8* NonMaximumSuppressionParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NonMaximumSuppressionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float nms_threshold = 1 [default = 0.3];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->nms_threshold(), target);
  }

  // optional int32 top_k = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->top_k(), target);
  }

  // optional float eta = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->eta(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NonMaximumSuppressionParameter)
  return target;
}

size_t NonMaximumSuppressionParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NonMaximumSuppressionParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional int32 top_k = 2;
    if (has_top_k()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->top_k());
    }

    // optional float nms_threshold = 1 [default = 0.3];
    if (has_nms_threshold()) {
      total_size += 1 + 4;
    }

    // optional float eta = 3 [default = 1];
    if (has_eta()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NonMaximumSuppressionParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.NonMaximumSuppressionParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const NonMaximumSuppressionParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NonMaximumSuppressionParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.NonMaximumSuppressionParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.NonMaximumSuppressionParameter)
    MergeFrom(*source);
  }
}

void NonMaximumSuppressionParameter::MergeFrom(const NonMaximumSuppressionParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NonMaximumSuppressionParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      top_k_ = from.top_k_;
    }
    if (cached_has_bits & 0x00000002u) {
      nms_threshold_ = from.nms_threshold_;
    }
    if (cached_has_bits & 0x00000004u) {
      eta_ = from.eta_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NonMaximumSuppressionParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.NonMaximumSuppressionParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NonMaximumSuppressionParameter::CopyFrom(const NonMaximumSuppressionParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NonMaximumSuppressionParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NonMaximumSuppressionParameter::IsInitialized() const {
  return true;
}

void NonMaximumSuppressionParameter::Swap(NonMaximumSuppressionParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NonMaximumSuppressionParameter::InternalSwap(NonMaximumSuppressionParameter* other) {
  using std::swap;
  swap(top_k_, other->top_k_);
  swap(nms_threshold_, other->nms_threshold_);
  swap(eta_, other->eta_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NonMaximumSuppressionParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SaveOutputParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SaveOutputParameter::kOutputDirectoryFieldNumber;
const int SaveOutputParameter::kOutputNamePrefixFieldNumber;
const int SaveOutputParameter::kOutputFormatFieldNumber;
const int SaveOutputParameter::kLabelMapFileFieldNumber;
const int SaveOutputParameter::kNameSizeFileFieldNumber;
const int SaveOutputParameter::kNumTestImageFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SaveOutputParameter::SaveOutputParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSaveOutputParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SaveOutputParameter)
}
SaveOutputParameter::SaveOutputParameter(const SaveOutputParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  output_directory_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_output_directory()) {
    output_directory_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_directory_);
  }
  output_name_prefix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_output_name_prefix()) {
    output_name_prefix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_name_prefix_);
  }
  output_format_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_output_format()) {
    output_format_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_format_);
  }
  label_map_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_label_map_file()) {
    label_map_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.label_map_file_);
  }
  name_size_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name_size_file()) {
    name_size_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_size_file_);
  }
  num_test_image_ = from.num_test_image_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SaveOutputParameter)
}

void SaveOutputParameter::SharedCtor() {
  _cached_size_ = 0;
  output_directory_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  output_name_prefix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  output_format_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  label_map_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  name_size_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  num_test_image_ = 0u;
}

SaveOutputParameter::~SaveOutputParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SaveOutputParameter)
  SharedDtor();
}

void SaveOutputParameter::SharedDtor() {
  output_directory_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  output_name_prefix_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  output_format_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  label_map_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  name_size_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void SaveOutputParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SaveOutputParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SaveOutputParameter& SaveOutputParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSaveOutputParameter();
  return *internal_default_instance();
}

SaveOutputParameter* SaveOutputParameter::New(::google::protobuf::Arena* arena) const {
  SaveOutputParameter* n = new SaveOutputParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SaveOutputParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SaveOutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!output_directory_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*output_directory_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!output_name_prefix_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*output_name_prefix_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(!output_format_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*output_format_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(!label_map_file_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*label_map_file_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(!name_size_file_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*name_size_file_.UnsafeRawStringPointer())->clear();
    }
  }
  num_test_image_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SaveOutputParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SaveOutputParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string output_directory = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_output_directory()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->output_directory().data(), static_cast<int>(this->output_directory().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SaveOutputParameter.output_directory");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string output_name_prefix = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_output_name_prefix()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->output_name_prefix().data(), static_cast<int>(this->output_name_prefix().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SaveOutputParameter.output_name_prefix");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string output_format = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_output_format()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->output_format().data(), static_cast<int>(this->output_format().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SaveOutputParameter.output_format");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string label_map_file = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_label_map_file()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->label_map_file().data(), static_cast<int>(this->label_map_file().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SaveOutputParameter.label_map_file");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string name_size_file = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name_size_file()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name_size_file().data(), static_cast<int>(this->name_size_file().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.SaveOutputParameter.name_size_file");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 num_test_image = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_num_test_image();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_test_image_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SaveOutputParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SaveOutputParameter)
  return false;
#undef DO_
}

void SaveOutputParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SaveOutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string output_directory = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->output_directory().data(), static_cast<int>(this->output_directory().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.output_directory");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->output_directory(), output);
  }

  // optional string output_name_prefix = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->output_name_prefix().data(), static_cast<int>(this->output_name_prefix().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.output_name_prefix");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->output_name_prefix(), output);
  }

  // optional string output_format = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->output_format().data(), static_cast<int>(this->output_format().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.output_format");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->output_format(), output);
  }

  // optional string label_map_file = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->label_map_file().data(), static_cast<int>(this->label_map_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.label_map_file");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->label_map_file(), output);
  }

  // optional string name_size_file = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name_size_file().data(), static_cast<int>(this->name_size_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.name_size_file");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->name_size_file(), output);
  }

  // optional uint32 num_test_image = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->num_test_image(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SaveOutputParameter)
}

::google::protobuf::uint8* SaveOutputParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SaveOutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string output_directory = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->output_directory().data(), static_cast<int>(this->output_directory().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.output_directory");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->output_directory(), target);
  }

  // optional string output_name_prefix = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->output_name_prefix().data(), static_cast<int>(this->output_name_prefix().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.output_name_prefix");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->output_name_prefix(), target);
  }

  // optional string output_format = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->output_format().data(), static_cast<int>(this->output_format().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.output_format");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->output_format(), target);
  }

  // optional string label_map_file = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->label_map_file().data(), static_cast<int>(this->label_map_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.label_map_file");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->label_map_file(), target);
  }

  // optional string name_size_file = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name_size_file().data(), static_cast<int>(this->name_size_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.SaveOutputParameter.name_size_file");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        5, this->name_size_file(), target);
  }

  // optional uint32 num_test_image = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->num_test_image(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SaveOutputParameter)
  return target;
}

size_t SaveOutputParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SaveOutputParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 63u) {
    // optional string output_directory = 1;
    if (has_output_directory()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->output_directory());
    }

    // optional string output_name_prefix = 2;
    if (has_output_name_prefix()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->output_name_prefix());
    }

    // optional string output_format = 3;
    if (has_output_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->output_format());
    }

    // optional string label_map_file = 4;
    if (has_label_map_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->label_map_file());
    }

    // optional string name_size_file = 5;
    if (has_name_size_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name_size_file());
    }

    // optional uint32 num_test_image = 6;
    if (has_num_test_image()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_test_image());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SaveOutputParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SaveOutputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const SaveOutputParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SaveOutputParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SaveOutputParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SaveOutputParameter)
    MergeFrom(*source);
  }
}

void SaveOutputParameter::MergeFrom(const SaveOutputParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SaveOutputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_output_directory();
      output_directory_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_directory_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_output_name_prefix();
      output_name_prefix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_name_prefix_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_output_format();
      output_format_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_format_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_label_map_file();
      label_map_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.label_map_file_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_name_size_file();
      name_size_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_size_file_);
    }
    if (cached_has_bits & 0x00000020u) {
      num_test_image_ = from.num_test_image_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SaveOutputParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SaveOutputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SaveOutputParameter::CopyFrom(const SaveOutputParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SaveOutputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SaveOutputParameter::IsInitialized() const {
  return true;
}

void SaveOutputParameter::Swap(SaveOutputParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SaveOutputParameter::InternalSwap(SaveOutputParameter* other) {
  using std::swap;
  output_directory_.Swap(&other->output_directory_);
  output_name_prefix_.Swap(&other->output_name_prefix_);
  output_format_.Swap(&other->output_format_);
  label_map_file_.Swap(&other->label_map_file_);
  name_size_file_.Swap(&other->name_size_file_);
  swap(num_test_image_, other->num_test_image_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SaveOutputParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DropoutParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DropoutParameter::kDropoutRatioFieldNumber;
const int DropoutParameter::kScaleTrainFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DropoutParameter::DropoutParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDropoutParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.DropoutParameter)
}
DropoutParameter::DropoutParameter(const DropoutParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&dropout_ratio_, &from.dropout_ratio_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_train_) -
    reinterpret_cast<char*>(&dropout_ratio_)) + sizeof(scale_train_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.DropoutParameter)
}

void DropoutParameter::SharedCtor() {
  _cached_size_ = 0;
  dropout_ratio_ = 0.5f;
  scale_train_ = true;
}

DropoutParameter::~DropoutParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.DropoutParameter)
  SharedDtor();
}

void DropoutParameter::SharedDtor() {
}

void DropoutParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DropoutParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DropoutParameter& DropoutParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDropoutParameter();
  return *internal_default_instance();
}

DropoutParameter* DropoutParameter::New(::google::protobuf::Arena* arena) const {
  DropoutParameter* n = new DropoutParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DropoutParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.DropoutParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    dropout_ratio_ = 0.5f;
    scale_train_ = true;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DropoutParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.DropoutParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float dropout_ratio = 1 [default = 0.5];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_dropout_ratio();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &dropout_ratio_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool scale_train = 2 [default = true];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_scale_train();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &scale_train_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.DropoutParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.DropoutParameter)
  return false;
#undef DO_
}

void DropoutParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.DropoutParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float dropout_ratio = 1 [default = 0.5];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->dropout_ratio(), output);
  }

  // optional bool scale_train = 2 [default = true];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->scale_train(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.DropoutParameter)
}

::google::protobuf::uint8* DropoutParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DropoutParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float dropout_ratio = 1 [default = 0.5];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->dropout_ratio(), target);
  }

  // optional bool scale_train = 2 [default = true];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->scale_train(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DropoutParameter)
  return target;
}

size_t DropoutParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DropoutParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional float dropout_ratio = 1 [default = 0.5];
    if (has_dropout_ratio()) {
      total_size += 1 + 4;
    }

    // optional bool scale_train = 2 [default = true];
    if (has_scale_train()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DropoutParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.DropoutParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const DropoutParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DropoutParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.DropoutParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.DropoutParameter)
    MergeFrom(*source);
  }
}

void DropoutParameter::MergeFrom(const DropoutParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DropoutParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      dropout_ratio_ = from.dropout_ratio_;
    }
    if (cached_has_bits & 0x00000002u) {
      scale_train_ = from.scale_train_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DropoutParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.DropoutParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DropoutParameter::CopyFrom(const DropoutParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DropoutParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DropoutParameter::IsInitialized() const {
  return true;
}

void DropoutParameter::Swap(DropoutParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DropoutParameter::InternalSwap(DropoutParameter* other) {
  using std::swap;
  swap(dropout_ratio_, other->dropout_ratio_);
  swap(scale_train_, other->scale_train_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DropoutParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DummyDataParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DummyDataParameter::kDataFillerFieldNumber;
const int DummyDataParameter::kShapeFieldNumber;
const int DummyDataParameter::kNumFieldNumber;
const int DummyDataParameter::kChannelsFieldNumber;
const int DummyDataParameter::kHeightFieldNumber;
const int DummyDataParameter::kWidthFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DummyDataParameter::DummyDataParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDummyDataParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.DummyDataParameter)
}
DummyDataParameter::DummyDataParameter(const DummyDataParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      data_filler_(from.data_filler_),
      num_(from.num_),
      channels_(from.channels_),
      height_(from.height_),
      width_(from.width_),
      shape_(from.shape_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.DummyDataParameter)
}

void DummyDataParameter::SharedCtor() {
  _cached_size_ = 0;
}

DummyDataParameter::~DummyDataParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.DummyDataParameter)
  SharedDtor();
}

void DummyDataParameter::SharedDtor() {
}

void DummyDataParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DummyDataParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DummyDataParameter& DummyDataParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsDummyDataParameter();
  return *internal_default_instance();
}

DummyDataParameter* DummyDataParameter::New(::google::protobuf::Arena* arena) const {
  DummyDataParameter* n = new DummyDataParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DummyDataParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.DummyDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_filler_.Clear();
  num_.Clear();
  channels_.Clear();
  height_.Clear();
  width_.Clear();
  shape_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DummyDataParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.DummyDataParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .opencv_caffe.FillerParameter data_filler = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_data_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 num = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 16u, input, this->mutable_num())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_num())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 channels = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 24u, input, this->mutable_channels())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_channels())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 height = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 32u, input, this->mutable_height())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_height())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 width = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 40u, input, this->mutable_width())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_width())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.BlobShape shape = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_shape()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.DummyDataParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.DummyDataParameter)
  return false;
#undef DO_
}

void DummyDataParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.DummyDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .opencv_caffe.FillerParameter data_filler = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->data_filler_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->data_filler(static_cast<int>(i)), output);
  }

  // repeated uint32 num = 2;
  for (int i = 0, n = this->num_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      2, this->num(i), output);
  }

  // repeated uint32 channels = 3;
  for (int i = 0, n = this->channels_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      3, this->channels(i), output);
  }

  // repeated uint32 height = 4;
  for (int i = 0, n = this->height_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      4, this->height(i), output);
  }

  // repeated uint32 width = 5;
  for (int i = 0, n = this->width_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      5, this->width(i), output);
  }

  // repeated .opencv_caffe.BlobShape shape = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->shape_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->shape(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.DummyDataParameter)
}

::google::protobuf::uint8* DummyDataParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.DummyDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .opencv_caffe.FillerParameter data_filler = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->data_filler_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->data_filler(static_cast<int>(i)), deterministic, target);
  }

  // repeated uint32 num = 2;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(2, this->num_, target);

  // repeated uint32 channels = 3;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(3, this->channels_, target);

  // repeated uint32 height = 4;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(4, this->height_, target);

  // repeated uint32 width = 5;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(5, this->width_, target);

  // repeated .opencv_caffe.BlobShape shape = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->shape_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, this->shape(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.DummyDataParameter)
  return target;
}

size_t DummyDataParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.DummyDataParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .opencv_caffe.FillerParameter data_filler = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->data_filler_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->data_filler(static_cast<int>(i)));
    }
  }

  // repeated uint32 num = 2;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->num_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->num_size());
    total_size += data_size;
  }

  // repeated uint32 channels = 3;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->channels_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->channels_size());
    total_size += data_size;
  }

  // repeated uint32 height = 4;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->height_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->height_size());
    total_size += data_size;
  }

  // repeated uint32 width = 5;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->width_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->width_size());
    total_size += data_size;
  }

  // repeated .opencv_caffe.BlobShape shape = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->shape_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->shape(static_cast<int>(i)));
    }
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DummyDataParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.DummyDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const DummyDataParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DummyDataParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.DummyDataParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.DummyDataParameter)
    MergeFrom(*source);
  }
}

void DummyDataParameter::MergeFrom(const DummyDataParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.DummyDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_filler_.MergeFrom(from.data_filler_);
  num_.MergeFrom(from.num_);
  channels_.MergeFrom(from.channels_);
  height_.MergeFrom(from.height_);
  width_.MergeFrom(from.width_);
  shape_.MergeFrom(from.shape_);
}

void DummyDataParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.DummyDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DummyDataParameter::CopyFrom(const DummyDataParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.DummyDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DummyDataParameter::IsInitialized() const {
  return true;
}

void DummyDataParameter::Swap(DummyDataParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DummyDataParameter::InternalSwap(DummyDataParameter* other) {
  using std::swap;
  data_filler_.InternalSwap(&other->data_filler_);
  num_.InternalSwap(&other->num_);
  channels_.InternalSwap(&other->channels_);
  height_.InternalSwap(&other->height_);
  width_.InternalSwap(&other->width_);
  shape_.InternalSwap(&other->shape_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DummyDataParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void EltwiseParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int EltwiseParameter::kOperationFieldNumber;
const int EltwiseParameter::kCoeffFieldNumber;
const int EltwiseParameter::kStableProdGradFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

EltwiseParameter::EltwiseParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsEltwiseParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.EltwiseParameter)
}
EltwiseParameter::EltwiseParameter(const EltwiseParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      coeff_(from.coeff_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&operation_, &from.operation_,
    static_cast<size_t>(reinterpret_cast<char*>(&stable_prod_grad_) -
    reinterpret_cast<char*>(&operation_)) + sizeof(stable_prod_grad_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.EltwiseParameter)
}

void EltwiseParameter::SharedCtor() {
  _cached_size_ = 0;
  operation_ = 1;
  stable_prod_grad_ = true;
}

EltwiseParameter::~EltwiseParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.EltwiseParameter)
  SharedDtor();
}

void EltwiseParameter::SharedDtor() {
}

void EltwiseParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* EltwiseParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const EltwiseParameter& EltwiseParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsEltwiseParameter();
  return *internal_default_instance();
}

EltwiseParameter* EltwiseParameter::New(::google::protobuf::Arena* arena) const {
  EltwiseParameter* n = new EltwiseParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void EltwiseParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.EltwiseParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  coeff_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    operation_ = 1;
    stable_prod_grad_ = true;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool EltwiseParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.EltwiseParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::EltwiseParameter_EltwiseOp_IsValid(value)) {
            set_operation(static_cast< ::opencv_caffe::EltwiseParameter_EltwiseOp >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float coeff = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 21u, input, this->mutable_coeff())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_coeff())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool stable_prod_grad = 3 [default = true];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_stable_prod_grad();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &stable_prod_grad_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.EltwiseParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.EltwiseParameter)
  return false;
#undef DO_
}

void EltwiseParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.EltwiseParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->operation(), output);
  }

  // repeated float coeff = 2;
  for (int i = 0, n = this->coeff_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      2, this->coeff(i), output);
  }

  // optional bool stable_prod_grad = 3 [default = true];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->stable_prod_grad(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.EltwiseParameter)
}

::google::protobuf::uint8* EltwiseParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.EltwiseParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->operation(), target);
  }

  // repeated float coeff = 2;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(2, this->coeff_, target);

  // optional bool stable_prod_grad = 3 [default = true];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->stable_prod_grad(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.EltwiseParameter)
  return target;
}

size_t EltwiseParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.EltwiseParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated float coeff = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->coeff_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->coeff_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 3u) {
    // optional .opencv_caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
    if (has_operation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation());
    }

    // optional bool stable_prod_grad = 3 [default = true];
    if (has_stable_prod_grad()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EltwiseParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.EltwiseParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const EltwiseParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const EltwiseParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.EltwiseParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.EltwiseParameter)
    MergeFrom(*source);
  }
}

void EltwiseParameter::MergeFrom(const EltwiseParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.EltwiseParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  coeff_.MergeFrom(from.coeff_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      operation_ = from.operation_;
    }
    if (cached_has_bits & 0x00000002u) {
      stable_prod_grad_ = from.stable_prod_grad_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void EltwiseParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.EltwiseParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void EltwiseParameter::CopyFrom(const EltwiseParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.EltwiseParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EltwiseParameter::IsInitialized() const {
  return true;
}

void EltwiseParameter::Swap(EltwiseParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void EltwiseParameter::InternalSwap(EltwiseParameter* other) {
  using std::swap;
  coeff_.InternalSwap(&other->coeff_);
  swap(operation_, other->operation_);
  swap(stable_prod_grad_, other->stable_prod_grad_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata EltwiseParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ELUParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ELUParameter::kAlphaFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ELUParameter::ELUParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsELUParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ELUParameter)
}
ELUParameter::ELUParameter(const ELUParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  alpha_ = from.alpha_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ELUParameter)
}

void ELUParameter::SharedCtor() {
  _cached_size_ = 0;
  alpha_ = 1;
}

ELUParameter::~ELUParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ELUParameter)
  SharedDtor();
}

void ELUParameter::SharedDtor() {
}

void ELUParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ELUParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ELUParameter& ELUParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsELUParameter();
  return *internal_default_instance();
}

ELUParameter* ELUParameter::New(::google::protobuf::Arena* arena) const {
  ELUParameter* n = new ELUParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ELUParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ELUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  alpha_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ELUParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ELUParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float alpha = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_alpha();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &alpha_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ELUParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ELUParameter)
  return false;
#undef DO_
}

void ELUParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ELUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float alpha = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->alpha(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ELUParameter)
}

::google::protobuf::uint8* ELUParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ELUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float alpha = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->alpha(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ELUParameter)
  return target;
}

size_t ELUParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ELUParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional float alpha = 1 [default = 1];
  if (has_alpha()) {
    total_size += 1 + 4;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ELUParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ELUParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ELUParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ELUParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ELUParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ELUParameter)
    MergeFrom(*source);
  }
}

void ELUParameter::MergeFrom(const ELUParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ELUParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_alpha()) {
    set_alpha(from.alpha());
  }
}

void ELUParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ELUParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ELUParameter::CopyFrom(const ELUParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ELUParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ELUParameter::IsInitialized() const {
  return true;
}

void ELUParameter::Swap(ELUParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ELUParameter::InternalSwap(ELUParameter* other) {
  using std::swap;
  swap(alpha_, other->alpha_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ELUParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void EmbedParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_EmbedParameter_default_instance_._instance.get_mutable()->weight_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_EmbedParameter_default_instance_._instance.get_mutable()->bias_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int EmbedParameter::kNumOutputFieldNumber;
const int EmbedParameter::kInputDimFieldNumber;
const int EmbedParameter::kBiasTermFieldNumber;
const int EmbedParameter::kWeightFillerFieldNumber;
const int EmbedParameter::kBiasFillerFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

EmbedParameter::EmbedParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsEmbedParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.EmbedParameter)
}
EmbedParameter::EmbedParameter(const EmbedParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_weight_filler()) {
    weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_);
  } else {
    weight_filler_ = NULL;
  }
  if (from.has_bias_filler()) {
    bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_);
  } else {
    bias_filler_ = NULL;
  }
  ::memcpy(&num_output_, &from.num_output_,
    static_cast<size_t>(reinterpret_cast<char*>(&bias_term_) -
    reinterpret_cast<char*>(&num_output_)) + sizeof(bias_term_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.EmbedParameter)
}

void EmbedParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&weight_filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&input_dim_) -
      reinterpret_cast<char*>(&weight_filler_)) + sizeof(input_dim_));
  bias_term_ = true;
}

EmbedParameter::~EmbedParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.EmbedParameter)
  SharedDtor();
}

void EmbedParameter::SharedDtor() {
  if (this != internal_default_instance()) delete weight_filler_;
  if (this != internal_default_instance()) delete bias_filler_;
}

void EmbedParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* EmbedParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const EmbedParameter& EmbedParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsEmbedParameter();
  return *internal_default_instance();
}

EmbedParameter* EmbedParameter::New(::google::protobuf::Arena* arena) const {
  EmbedParameter* n = new EmbedParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void EmbedParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.EmbedParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(weight_filler_ != NULL);
      weight_filler_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(bias_filler_ != NULL);
      bias_filler_->Clear();
    }
  }
  if (cached_has_bits & 28u) {
    ::memset(&num_output_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&input_dim_) -
        reinterpret_cast<char*>(&num_output_)) + sizeof(input_dim_));
    bias_term_ = true;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool EmbedParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.EmbedParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_output = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_num_output();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_output_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 input_dim = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_input_dim();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &input_dim_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool bias_term = 3 [default = true];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_bias_term();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &bias_term_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter weight_filler = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_weight_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter bias_filler = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.EmbedParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.EmbedParameter)
  return false;
#undef DO_
}

void EmbedParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.EmbedParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output);
  }

  // optional uint32 input_dim = 2;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->input_dim(), output);
  }

  // optional bool bias_term = 3 [default = true];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->bias_term(), output);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, *this->weight_filler_, output);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 5;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->bias_filler_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.EmbedParameter)
}

::google::protobuf::uint8* EmbedParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.EmbedParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target);
  }

  // optional uint32 input_dim = 2;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->input_dim(), target);
  }

  // optional bool bias_term = 3 [default = true];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->bias_term(), target);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 4;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, *this->weight_filler_, deterministic, target);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 5;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, *this->bias_filler_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.EmbedParameter)
  return target;
}

size_t EmbedParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.EmbedParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 31u) {
    // optional .opencv_caffe.FillerParameter weight_filler = 4;
    if (has_weight_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->weight_filler_);
    }

    // optional .opencv_caffe.FillerParameter bias_filler = 5;
    if (has_bias_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_filler_);
    }

    // optional uint32 num_output = 1;
    if (has_num_output()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_output());
    }

    // optional uint32 input_dim = 2;
    if (has_input_dim()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->input_dim());
    }

    // optional bool bias_term = 3 [default = true];
    if (has_bias_term()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EmbedParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.EmbedParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const EmbedParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const EmbedParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.EmbedParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.EmbedParameter)
    MergeFrom(*source);
  }
}

void EmbedParameter::MergeFrom(const EmbedParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.EmbedParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.weight_filler());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.bias_filler());
    }
    if (cached_has_bits & 0x00000004u) {
      num_output_ = from.num_output_;
    }
    if (cached_has_bits & 0x00000008u) {
      input_dim_ = from.input_dim_;
    }
    if (cached_has_bits & 0x00000010u) {
      bias_term_ = from.bias_term_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void EmbedParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.EmbedParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void EmbedParameter::CopyFrom(const EmbedParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.EmbedParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EmbedParameter::IsInitialized() const {
  return true;
}

void EmbedParameter::Swap(EmbedParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void EmbedParameter::InternalSwap(EmbedParameter* other) {
  using std::swap;
  swap(weight_filler_, other->weight_filler_);
  swap(bias_filler_, other->bias_filler_);
  swap(num_output_, other->num_output_);
  swap(input_dim_, other->input_dim_);
  swap(bias_term_, other->bias_term_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata EmbedParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ExpParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ExpParameter::kBaseFieldNumber;
const int ExpParameter::kScaleFieldNumber;
const int ExpParameter::kShiftFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ExpParameter::ExpParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsExpParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ExpParameter)
}
ExpParameter::ExpParameter(const ExpParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&shift_, &from.shift_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&shift_)) + sizeof(scale_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ExpParameter)
}

void ExpParameter::SharedCtor() {
  _cached_size_ = 0;
  shift_ = 0;
  base_ = -1;
  scale_ = 1;
}

ExpParameter::~ExpParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ExpParameter)
  SharedDtor();
}

void ExpParameter::SharedDtor() {
}

void ExpParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ExpParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ExpParameter& ExpParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsExpParameter();
  return *internal_default_instance();
}

ExpParameter* ExpParameter::New(::google::protobuf::Arena* arena) const {
  ExpParameter* n = new ExpParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ExpParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ExpParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    shift_ = 0;
    base_ = -1;
    scale_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ExpParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ExpParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float base = 1 [default = -1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_base();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &base_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float shift = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_shift();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &shift_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ExpParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ExpParameter)
  return false;
#undef DO_
}

void ExpParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ExpParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float base = 1 [default = -1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->base(), output);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output);
  }

  // optional float shift = 3 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->shift(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ExpParameter)
}

::google::protobuf::uint8* ExpParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ExpParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float base = 1 [default = -1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->base(), target);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target);
  }

  // optional float shift = 3 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->shift(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ExpParameter)
  return target;
}

size_t ExpParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ExpParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional float shift = 3 [default = 0];
    if (has_shift()) {
      total_size += 1 + 4;
    }

    // optional float base = 1 [default = -1];
    if (has_base()) {
      total_size += 1 + 4;
    }

    // optional float scale = 2 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ExpParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ExpParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ExpParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ExpParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ExpParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ExpParameter)
    MergeFrom(*source);
  }
}

void ExpParameter::MergeFrom(const ExpParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ExpParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      shift_ = from.shift_;
    }
    if (cached_has_bits & 0x00000002u) {
      base_ = from.base_;
    }
    if (cached_has_bits & 0x00000004u) {
      scale_ = from.scale_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ExpParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ExpParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ExpParameter::CopyFrom(const ExpParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ExpParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExpParameter::IsInitialized() const {
  return true;
}

void ExpParameter::Swap(ExpParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ExpParameter::InternalSwap(ExpParameter* other) {
  using std::swap;
  swap(shift_, other->shift_);
  swap(base_, other->base_);
  swap(scale_, other->scale_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ExpParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void FlattenParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FlattenParameter::kAxisFieldNumber;
const int FlattenParameter::kEndAxisFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FlattenParameter::FlattenParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsFlattenParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.FlattenParameter)
}
FlattenParameter::FlattenParameter(const FlattenParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&axis_, &from.axis_,
    static_cast<size_t>(reinterpret_cast<char*>(&end_axis_) -
    reinterpret_cast<char*>(&axis_)) + sizeof(end_axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.FlattenParameter)
}

void FlattenParameter::SharedCtor() {
  _cached_size_ = 0;
  axis_ = 1;
  end_axis_ = -1;
}

FlattenParameter::~FlattenParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.FlattenParameter)
  SharedDtor();
}

void FlattenParameter::SharedDtor() {
}

void FlattenParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* FlattenParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const FlattenParameter& FlattenParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsFlattenParameter();
  return *internal_default_instance();
}

FlattenParameter* FlattenParameter::New(::google::protobuf::Arena* arena) const {
  FlattenParameter* n = new FlattenParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FlattenParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.FlattenParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    axis_ = 1;
    end_axis_ = -1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FlattenParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.FlattenParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 axis = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 end_axis = 2 [default = -1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_end_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &end_axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.FlattenParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.FlattenParameter)
  return false;
#undef DO_
}

void FlattenParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.FlattenParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output);
  }

  // optional int32 end_axis = 2 [default = -1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->end_axis(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.FlattenParameter)
}

::google::protobuf::uint8* FlattenParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.FlattenParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target);
  }

  // optional int32 end_axis = 2 [default = -1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->end_axis(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.FlattenParameter)
  return target;
}

size_t FlattenParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.FlattenParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 axis = 1 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional int32 end_axis = 2 [default = -1];
    if (has_end_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->end_axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FlattenParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.FlattenParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const FlattenParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const FlattenParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.FlattenParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.FlattenParameter)
    MergeFrom(*source);
  }
}

void FlattenParameter::MergeFrom(const FlattenParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.FlattenParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00000002u) {
      end_axis_ = from.end_axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FlattenParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.FlattenParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void FlattenParameter::CopyFrom(const FlattenParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.FlattenParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FlattenParameter::IsInitialized() const {
  return true;
}

void FlattenParameter::Swap(FlattenParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FlattenParameter::InternalSwap(FlattenParameter* other) {
  using std::swap;
  swap(axis_, other->axis_);
  swap(end_axis_, other->end_axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata FlattenParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void HDF5DataParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HDF5DataParameter::kSourceFieldNumber;
const int HDF5DataParameter::kBatchSizeFieldNumber;
const int HDF5DataParameter::kShuffleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HDF5DataParameter::HDF5DataParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5DataParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.HDF5DataParameter)
}
HDF5DataParameter::HDF5DataParameter(const HDF5DataParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_source()) {
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
  ::memcpy(&batch_size_, &from.batch_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&shuffle_) -
    reinterpret_cast<char*>(&batch_size_)) + sizeof(shuffle_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.HDF5DataParameter)
}

void HDF5DataParameter::SharedCtor() {
  _cached_size_ = 0;
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&batch_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&shuffle_) -
      reinterpret_cast<char*>(&batch_size_)) + sizeof(shuffle_));
}

HDF5DataParameter::~HDF5DataParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.HDF5DataParameter)
  SharedDtor();
}

void HDF5DataParameter::SharedDtor() {
  source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void HDF5DataParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* HDF5DataParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const HDF5DataParameter& HDF5DataParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5DataParameter();
  return *internal_default_instance();
}

HDF5DataParameter* HDF5DataParameter::New(::google::protobuf::Arena* arena) const {
  HDF5DataParameter* n = new HDF5DataParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void HDF5DataParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.HDF5DataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!source_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*source_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 6u) {
    ::memset(&batch_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&shuffle_) -
        reinterpret_cast<char*>(&batch_size_)) + sizeof(shuffle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HDF5DataParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.HDF5DataParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string source = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source().data(), static_cast<int>(this->source().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.HDF5DataParameter.source");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 batch_size = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_batch_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &batch_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool shuffle = 3 [default = false];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_shuffle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &shuffle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.HDF5DataParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.HDF5DataParameter)
  return false;
#undef DO_
}

void HDF5DataParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.HDF5DataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.HDF5DataParameter.source");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->source(), output);
  }

  // optional uint32 batch_size = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->batch_size(), output);
  }

  // optional bool shuffle = 3 [default = false];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->shuffle(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.HDF5DataParameter)
}

::google::protobuf::uint8* HDF5DataParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HDF5DataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.HDF5DataParameter.source");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->source(), target);
  }

  // optional uint32 batch_size = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->batch_size(), target);
  }

  // optional bool shuffle = 3 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->shuffle(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HDF5DataParameter)
  return target;
}

size_t HDF5DataParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HDF5DataParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional string source = 1;
    if (has_source()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->source());
    }

    // optional uint32 batch_size = 2;
    if (has_batch_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->batch_size());
    }

    // optional bool shuffle = 3 [default = false];
    if (has_shuffle()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HDF5DataParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.HDF5DataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const HDF5DataParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const HDF5DataParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.HDF5DataParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.HDF5DataParameter)
    MergeFrom(*source);
  }
}

void HDF5DataParameter::MergeFrom(const HDF5DataParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HDF5DataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_source();
      source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
    }
    if (cached_has_bits & 0x00000002u) {
      batch_size_ = from.batch_size_;
    }
    if (cached_has_bits & 0x00000004u) {
      shuffle_ = from.shuffle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void HDF5DataParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.HDF5DataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void HDF5DataParameter::CopyFrom(const HDF5DataParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HDF5DataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HDF5DataParameter::IsInitialized() const {
  return true;
}

void HDF5DataParameter::Swap(HDF5DataParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HDF5DataParameter::InternalSwap(HDF5DataParameter* other) {
  using std::swap;
  source_.Swap(&other->source_);
  swap(batch_size_, other->batch_size_);
  swap(shuffle_, other->shuffle_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata HDF5DataParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void HDF5OutputParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HDF5OutputParameter::kFileNameFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HDF5OutputParameter::HDF5OutputParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5OutputParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.HDF5OutputParameter)
}
HDF5OutputParameter::HDF5OutputParameter(const HDF5OutputParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  file_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_file_name()) {
    file_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.file_name_);
  }
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.HDF5OutputParameter)
}

void HDF5OutputParameter::SharedCtor() {
  _cached_size_ = 0;
  file_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

HDF5OutputParameter::~HDF5OutputParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.HDF5OutputParameter)
  SharedDtor();
}

void HDF5OutputParameter::SharedDtor() {
  file_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void HDF5OutputParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* HDF5OutputParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const HDF5OutputParameter& HDF5OutputParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHDF5OutputParameter();
  return *internal_default_instance();
}

HDF5OutputParameter* HDF5OutputParameter::New(::google::protobuf::Arena* arena) const {
  HDF5OutputParameter* n = new HDF5OutputParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void HDF5OutputParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.HDF5OutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!file_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*file_name_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HDF5OutputParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.HDF5OutputParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string file_name = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->file_name().data(), static_cast<int>(this->file_name().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.HDF5OutputParameter.file_name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.HDF5OutputParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.HDF5OutputParameter)
  return false;
#undef DO_
}

void HDF5OutputParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.HDF5OutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string file_name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->file_name().data(), static_cast<int>(this->file_name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.HDF5OutputParameter.file_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->file_name(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.HDF5OutputParameter)
}

::google::protobuf::uint8* HDF5OutputParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HDF5OutputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string file_name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->file_name().data(), static_cast<int>(this->file_name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.HDF5OutputParameter.file_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->file_name(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HDF5OutputParameter)
  return target;
}

size_t HDF5OutputParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HDF5OutputParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional string file_name = 1;
  if (has_file_name()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->file_name());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HDF5OutputParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.HDF5OutputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const HDF5OutputParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const HDF5OutputParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.HDF5OutputParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.HDF5OutputParameter)
    MergeFrom(*source);
  }
}

void HDF5OutputParameter::MergeFrom(const HDF5OutputParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HDF5OutputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_file_name()) {
    set_has_file_name();
    file_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.file_name_);
  }
}

void HDF5OutputParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.HDF5OutputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void HDF5OutputParameter::CopyFrom(const HDF5OutputParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HDF5OutputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HDF5OutputParameter::IsInitialized() const {
  return true;
}

void HDF5OutputParameter::Swap(HDF5OutputParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HDF5OutputParameter::InternalSwap(HDF5OutputParameter* other) {
  using std::swap;
  file_name_.Swap(&other->file_name_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata HDF5OutputParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void HingeLossParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HingeLossParameter::kNormFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HingeLossParameter::HingeLossParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHingeLossParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.HingeLossParameter)
}
HingeLossParameter::HingeLossParameter(const HingeLossParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  norm_ = from.norm_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.HingeLossParameter)
}

void HingeLossParameter::SharedCtor() {
  _cached_size_ = 0;
  norm_ = 1;
}

HingeLossParameter::~HingeLossParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.HingeLossParameter)
  SharedDtor();
}

void HingeLossParameter::SharedDtor() {
}

void HingeLossParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* HingeLossParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const HingeLossParameter& HingeLossParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsHingeLossParameter();
  return *internal_default_instance();
}

HingeLossParameter* HingeLossParameter::New(::google::protobuf::Arena* arena) const {
  HingeLossParameter* n = new HingeLossParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void HingeLossParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.HingeLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  norm_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HingeLossParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.HingeLossParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::HingeLossParameter_Norm_IsValid(value)) {
            set_norm(static_cast< ::opencv_caffe::HingeLossParameter_Norm >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.HingeLossParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.HingeLossParameter)
  return false;
#undef DO_
}

void HingeLossParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.HingeLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->norm(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.HingeLossParameter)
}

::google::protobuf::uint8* HingeLossParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.HingeLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->norm(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.HingeLossParameter)
  return target;
}

size_t HingeLossParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.HingeLossParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .opencv_caffe.HingeLossParameter.Norm norm = 1 [default = L1];
  if (has_norm()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->norm());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HingeLossParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.HingeLossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const HingeLossParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const HingeLossParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.HingeLossParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.HingeLossParameter)
    MergeFrom(*source);
  }
}

void HingeLossParameter::MergeFrom(const HingeLossParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.HingeLossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_norm()) {
    set_norm(from.norm());
  }
}

void HingeLossParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.HingeLossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void HingeLossParameter::CopyFrom(const HingeLossParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.HingeLossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HingeLossParameter::IsInitialized() const {
  return true;
}

void HingeLossParameter::Swap(HingeLossParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HingeLossParameter::InternalSwap(HingeLossParameter* other) {
  using std::swap;
  swap(norm_, other->norm_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata HingeLossParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ImageDataParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ImageDataParameter::kSourceFieldNumber;
const int ImageDataParameter::kBatchSizeFieldNumber;
const int ImageDataParameter::kRandSkipFieldNumber;
const int ImageDataParameter::kShuffleFieldNumber;
const int ImageDataParameter::kNewHeightFieldNumber;
const int ImageDataParameter::kNewWidthFieldNumber;
const int ImageDataParameter::kIsColorFieldNumber;
const int ImageDataParameter::kScaleFieldNumber;
const int ImageDataParameter::kMeanFileFieldNumber;
const int ImageDataParameter::kCropSizeFieldNumber;
const int ImageDataParameter::kMirrorFieldNumber;
const int ImageDataParameter::kRootFolderFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ImageDataParameter::ImageDataParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsImageDataParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ImageDataParameter)
}
ImageDataParameter::ImageDataParameter(const ImageDataParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_source()) {
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_mean_file()) {
    mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
  }
  root_folder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_root_folder()) {
    root_folder_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.root_folder_);
  }
  ::memcpy(&crop_size_, &from.crop_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&batch_size_) -
    reinterpret_cast<char*>(&crop_size_)) + sizeof(batch_size_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ImageDataParameter)
}

void ImageDataParameter::SharedCtor() {
  _cached_size_ = 0;
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  root_folder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&crop_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&new_width_) -
      reinterpret_cast<char*>(&crop_size_)) + sizeof(new_width_));
  is_color_ = true;
  scale_ = 1;
  batch_size_ = 1u;
}

ImageDataParameter::~ImageDataParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ImageDataParameter)
  SharedDtor();
}

void ImageDataParameter::SharedDtor() {
  source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  root_folder_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void ImageDataParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ImageDataParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ImageDataParameter& ImageDataParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsImageDataParameter();
  return *internal_default_instance();
}

ImageDataParameter* ImageDataParameter::New(::google::protobuf::Arena* arena) const {
  ImageDataParameter* n = new ImageDataParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ImageDataParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ImageDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!source_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*source_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!mean_file_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*mean_file_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(!root_folder_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*root_folder_.UnsafeRawStringPointer())->clear();
    }
  }
  if (cached_has_bits & 248u) {
    ::memset(&crop_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&new_height_) -
        reinterpret_cast<char*>(&crop_size_)) + sizeof(new_height_));
  }
  if (cached_has_bits & 3840u) {
    new_width_ = 0u;
    is_color_ = true;
    scale_ = 1;
    batch_size_ = 1u;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ImageDataParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ImageDataParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string source = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source().data(), static_cast<int>(this->source().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.ImageDataParameter.source");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string mean_file = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_mean_file()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->mean_file().data(), static_cast<int>(this->mean_file().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.ImageDataParameter.mean_file");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 batch_size = 4 [default = 1];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_batch_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &batch_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 crop_size = 5 [default = 0];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_crop_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &crop_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool mirror = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_mirror();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &mirror_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 rand_skip = 7 [default = 0];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_rand_skip();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rand_skip_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool shuffle = 8 [default = false];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          set_has_shuffle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &shuffle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 new_height = 9 [default = 0];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_new_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &new_height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 new_width = 10 [default = 0];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_new_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &new_width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_color = 11 [default = true];
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          set_has_is_color();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_color_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string root_folder = 12 [default = ""];
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_root_folder()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->root_folder().data(), static_cast<int>(this->root_folder().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.ImageDataParameter.root_folder");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ImageDataParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ImageDataParameter)
  return false;
#undef DO_
}

void ImageDataParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ImageDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ImageDataParameter.source");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->source(), output);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output);
  }

  // optional string mean_file = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ImageDataParameter.mean_file");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->mean_file(), output);
  }

  // optional uint32 batch_size = 4 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->batch_size(), output);
  }

  // optional uint32 crop_size = 5 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crop_size(), output);
  }

  // optional bool mirror = 6 [default = false];
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mirror(), output);
  }

  // optional uint32 rand_skip = 7 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->rand_skip(), output);
  }

  // optional bool shuffle = 8 [default = false];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->shuffle(), output);
  }

  // optional uint32 new_height = 9 [default = 0];
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->new_height(), output);
  }

  // optional uint32 new_width = 10 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->new_width(), output);
  }

  // optional bool is_color = 11 [default = true];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->is_color(), output);
  }

  // optional string root_folder = 12 [default = ""];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->root_folder().data(), static_cast<int>(this->root_folder().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ImageDataParameter.root_folder");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      12, this->root_folder(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ImageDataParameter)
}

::google::protobuf::uint8* ImageDataParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ImageDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ImageDataParameter.source");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->source(), target);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target);
  }

  // optional string mean_file = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ImageDataParameter.mean_file");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->mean_file(), target);
  }

  // optional uint32 batch_size = 4 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->batch_size(), target);
  }

  // optional uint32 crop_size = 5 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->crop_size(), target);
  }

  // optional bool mirror = 6 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->mirror(), target);
  }

  // optional uint32 rand_skip = 7 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->rand_skip(), target);
  }

  // optional bool shuffle = 8 [default = false];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->shuffle(), target);
  }

  // optional uint32 new_height = 9 [default = 0];
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->new_height(), target);
  }

  // optional uint32 new_width = 10 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->new_width(), target);
  }

  // optional bool is_color = 11 [default = true];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->is_color(), target);
  }

  // optional string root_folder = 12 [default = ""];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->root_folder().data(), static_cast<int>(this->root_folder().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.ImageDataParameter.root_folder");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        12, this->root_folder(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ImageDataParameter)
  return target;
}

size_t ImageDataParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ImageDataParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional string source = 1;
    if (has_source()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->source());
    }

    // optional string mean_file = 3;
    if (has_mean_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->mean_file());
    }

    // optional string root_folder = 12 [default = ""];
    if (has_root_folder()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->root_folder());
    }

    // optional uint32 crop_size = 5 [default = 0];
    if (has_crop_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->crop_size());
    }

    // optional uint32 rand_skip = 7 [default = 0];
    if (has_rand_skip()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->rand_skip());
    }

    // optional bool shuffle = 8 [default = false];
    if (has_shuffle()) {
      total_size += 1 + 1;
    }

    // optional bool mirror = 6 [default = false];
    if (has_mirror()) {
      total_size += 1 + 1;
    }

    // optional uint32 new_height = 9 [default = 0];
    if (has_new_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->new_height());
    }

  }
  if (_has_bits_[8 / 32] & 3840u) {
    // optional uint32 new_width = 10 [default = 0];
    if (has_new_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->new_width());
    }

    // optional bool is_color = 11 [default = true];
    if (has_is_color()) {
      total_size += 1 + 1;
    }

    // optional float scale = 2 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

    // optional uint32 batch_size = 4 [default = 1];
    if (has_batch_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->batch_size());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ImageDataParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ImageDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ImageDataParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ImageDataParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ImageDataParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ImageDataParameter)
    MergeFrom(*source);
  }
}

void ImageDataParameter::MergeFrom(const ImageDataParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ImageDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_source();
      source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_mean_file();
      mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_root_folder();
      root_folder_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.root_folder_);
    }
    if (cached_has_bits & 0x00000008u) {
      crop_size_ = from.crop_size_;
    }
    if (cached_has_bits & 0x00000010u) {
      rand_skip_ = from.rand_skip_;
    }
    if (cached_has_bits & 0x00000020u) {
      shuffle_ = from.shuffle_;
    }
    if (cached_has_bits & 0x00000040u) {
      mirror_ = from.mirror_;
    }
    if (cached_has_bits & 0x00000080u) {
      new_height_ = from.new_height_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 3840u) {
    if (cached_has_bits & 0x00000100u) {
      new_width_ = from.new_width_;
    }
    if (cached_has_bits & 0x00000200u) {
      is_color_ = from.is_color_;
    }
    if (cached_has_bits & 0x00000400u) {
      scale_ = from.scale_;
    }
    if (cached_has_bits & 0x00000800u) {
      batch_size_ = from.batch_size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ImageDataParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ImageDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ImageDataParameter::CopyFrom(const ImageDataParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ImageDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ImageDataParameter::IsInitialized() const {
  return true;
}

void ImageDataParameter::Swap(ImageDataParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ImageDataParameter::InternalSwap(ImageDataParameter* other) {
  using std::swap;
  source_.Swap(&other->source_);
  mean_file_.Swap(&other->mean_file_);
  root_folder_.Swap(&other->root_folder_);
  swap(crop_size_, other->crop_size_);
  swap(rand_skip_, other->rand_skip_);
  swap(shuffle_, other->shuffle_);
  swap(mirror_, other->mirror_);
  swap(new_height_, other->new_height_);
  swap(new_width_, other->new_width_);
  swap(is_color_, other->is_color_);
  swap(scale_, other->scale_);
  swap(batch_size_, other->batch_size_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ImageDataParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void InfogainLossParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int InfogainLossParameter::kSourceFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

InfogainLossParameter::InfogainLossParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInfogainLossParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.InfogainLossParameter)
}
InfogainLossParameter::InfogainLossParameter(const InfogainLossParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_source()) {
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.InfogainLossParameter)
}

void InfogainLossParameter::SharedCtor() {
  _cached_size_ = 0;
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

InfogainLossParameter::~InfogainLossParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.InfogainLossParameter)
  SharedDtor();
}

void InfogainLossParameter::SharedDtor() {
  source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void InfogainLossParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* InfogainLossParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const InfogainLossParameter& InfogainLossParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInfogainLossParameter();
  return *internal_default_instance();
}

InfogainLossParameter* InfogainLossParameter::New(::google::protobuf::Arena* arena) const {
  InfogainLossParameter* n = new InfogainLossParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void InfogainLossParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.InfogainLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!source_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*source_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool InfogainLossParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.InfogainLossParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string source = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source().data(), static_cast<int>(this->source().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.InfogainLossParameter.source");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.InfogainLossParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.InfogainLossParameter)
  return false;
#undef DO_
}

void InfogainLossParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.InfogainLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.InfogainLossParameter.source");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->source(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.InfogainLossParameter)
}

::google::protobuf::uint8* InfogainLossParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InfogainLossParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.InfogainLossParameter.source");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->source(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InfogainLossParameter)
  return target;
}

size_t InfogainLossParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InfogainLossParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional string source = 1;
  if (has_source()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->source());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InfogainLossParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.InfogainLossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const InfogainLossParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const InfogainLossParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.InfogainLossParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.InfogainLossParameter)
    MergeFrom(*source);
  }
}

void InfogainLossParameter::MergeFrom(const InfogainLossParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InfogainLossParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_source()) {
    set_has_source();
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
}

void InfogainLossParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.InfogainLossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void InfogainLossParameter::CopyFrom(const InfogainLossParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InfogainLossParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InfogainLossParameter::IsInitialized() const {
  return true;
}

void InfogainLossParameter::Swap(InfogainLossParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void InfogainLossParameter::InternalSwap(InfogainLossParameter* other) {
  using std::swap;
  source_.Swap(&other->source_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata InfogainLossParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void InnerProductParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_InnerProductParameter_default_instance_._instance.get_mutable()->weight_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_InnerProductParameter_default_instance_._instance.get_mutable()->bias_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int InnerProductParameter::kNumOutputFieldNumber;
const int InnerProductParameter::kBiasTermFieldNumber;
const int InnerProductParameter::kWeightFillerFieldNumber;
const int InnerProductParameter::kBiasFillerFieldNumber;
const int InnerProductParameter::kAxisFieldNumber;
const int InnerProductParameter::kTransposeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

InnerProductParameter::InnerProductParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInnerProductParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.InnerProductParameter)
}
InnerProductParameter::InnerProductParameter(const InnerProductParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_weight_filler()) {
    weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_);
  } else {
    weight_filler_ = NULL;
  }
  if (from.has_bias_filler()) {
    bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_);
  } else {
    bias_filler_ = NULL;
  }
  ::memcpy(&num_output_, &from.num_output_,
    static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
    reinterpret_cast<char*>(&num_output_)) + sizeof(axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.InnerProductParameter)
}

void InnerProductParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&weight_filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&transpose_) -
      reinterpret_cast<char*>(&weight_filler_)) + sizeof(transpose_));
  bias_term_ = true;
  axis_ = 1;
}

InnerProductParameter::~InnerProductParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.InnerProductParameter)
  SharedDtor();
}

void InnerProductParameter::SharedDtor() {
  if (this != internal_default_instance()) delete weight_filler_;
  if (this != internal_default_instance()) delete bias_filler_;
}

void InnerProductParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* InnerProductParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const InnerProductParameter& InnerProductParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInnerProductParameter();
  return *internal_default_instance();
}

InnerProductParameter* InnerProductParameter::New(::google::protobuf::Arena* arena) const {
  InnerProductParameter* n = new InnerProductParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void InnerProductParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.InnerProductParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(weight_filler_ != NULL);
      weight_filler_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(bias_filler_ != NULL);
      bias_filler_->Clear();
    }
  }
  if (cached_has_bits & 60u) {
    ::memset(&num_output_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&transpose_) -
        reinterpret_cast<char*>(&num_output_)) + sizeof(transpose_));
    bias_term_ = true;
    axis_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool InnerProductParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.InnerProductParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_output = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_num_output();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_output_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool bias_term = 2 [default = true];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_bias_term();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &bias_term_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter weight_filler = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_weight_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter bias_filler = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 5 [default = 1];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool transpose = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_transpose();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &transpose_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.InnerProductParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.InnerProductParameter)
  return false;
#undef DO_
}

void InnerProductParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.InnerProductParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output);
  }

  // optional bool bias_term = 2 [default = true];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->bias_term(), output);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->weight_filler_, output);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, *this->bias_filler_, output);
  }

  // optional int32 axis = 5 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->axis(), output);
  }

  // optional bool transpose = 6 [default = false];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->transpose(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.InnerProductParameter)
}

::google::protobuf::uint8* InnerProductParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InnerProductParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target);
  }

  // optional bool bias_term = 2 [default = true];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->bias_term(), target);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, *this->weight_filler_, deterministic, target);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 4;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, *this->bias_filler_, deterministic, target);
  }

  // optional int32 axis = 5 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->axis(), target);
  }

  // optional bool transpose = 6 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->transpose(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InnerProductParameter)
  return target;
}

size_t InnerProductParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InnerProductParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 63u) {
    // optional .opencv_caffe.FillerParameter weight_filler = 3;
    if (has_weight_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->weight_filler_);
    }

    // optional .opencv_caffe.FillerParameter bias_filler = 4;
    if (has_bias_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_filler_);
    }

    // optional uint32 num_output = 1;
    if (has_num_output()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_output());
    }

    // optional bool transpose = 6 [default = false];
    if (has_transpose()) {
      total_size += 1 + 1;
    }

    // optional bool bias_term = 2 [default = true];
    if (has_bias_term()) {
      total_size += 1 + 1;
    }

    // optional int32 axis = 5 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InnerProductParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.InnerProductParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const InnerProductParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const InnerProductParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.InnerProductParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.InnerProductParameter)
    MergeFrom(*source);
  }
}

void InnerProductParameter::MergeFrom(const InnerProductParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InnerProductParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.weight_filler());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.bias_filler());
    }
    if (cached_has_bits & 0x00000004u) {
      num_output_ = from.num_output_;
    }
    if (cached_has_bits & 0x00000008u) {
      transpose_ = from.transpose_;
    }
    if (cached_has_bits & 0x00000010u) {
      bias_term_ = from.bias_term_;
    }
    if (cached_has_bits & 0x00000020u) {
      axis_ = from.axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void InnerProductParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.InnerProductParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void InnerProductParameter::CopyFrom(const InnerProductParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InnerProductParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InnerProductParameter::IsInitialized() const {
  return true;
}

void InnerProductParameter::Swap(InnerProductParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void InnerProductParameter::InternalSwap(InnerProductParameter* other) {
  using std::swap;
  swap(weight_filler_, other->weight_filler_);
  swap(bias_filler_, other->bias_filler_);
  swap(num_output_, other->num_output_);
  swap(transpose_, other->transpose_);
  swap(bias_term_, other->bias_term_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata InnerProductParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void InputParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int InputParameter::kShapeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

InputParameter::InputParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInputParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.InputParameter)
}
InputParameter::InputParameter(const InputParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      shape_(from.shape_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.InputParameter)
}

void InputParameter::SharedCtor() {
  _cached_size_ = 0;
}

InputParameter::~InputParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.InputParameter)
  SharedDtor();
}

void InputParameter::SharedDtor() {
}

void InputParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* InputParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const InputParameter& InputParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsInputParameter();
  return *internal_default_instance();
}

InputParameter* InputParameter::New(::google::protobuf::Arena* arena) const {
  InputParameter* n = new InputParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void InputParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.InputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  shape_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool InputParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.InputParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .opencv_caffe.BlobShape shape = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_shape()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.InputParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.InputParameter)
  return false;
#undef DO_
}

void InputParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.InputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .opencv_caffe.BlobShape shape = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->shape_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->shape(static_cast<int>(i)), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.InputParameter)
}

::google::protobuf::uint8* InputParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.InputParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .opencv_caffe.BlobShape shape = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->shape_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->shape(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.InputParameter)
  return target;
}

size_t InputParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.InputParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .opencv_caffe.BlobShape shape = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->shape_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->shape(static_cast<int>(i)));
    }
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InputParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.InputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const InputParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const InputParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.InputParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.InputParameter)
    MergeFrom(*source);
  }
}

void InputParameter::MergeFrom(const InputParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.InputParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  shape_.MergeFrom(from.shape_);
}

void InputParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.InputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void InputParameter::CopyFrom(const InputParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.InputParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InputParameter::IsInitialized() const {
  return true;
}

void InputParameter::Swap(InputParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void InputParameter::InternalSwap(InputParameter* other) {
  using std::swap;
  shape_.InternalSwap(&other->shape_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata InputParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void LogParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int LogParameter::kBaseFieldNumber;
const int LogParameter::kScaleFieldNumber;
const int LogParameter::kShiftFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

LogParameter::LogParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLogParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.LogParameter)
}
LogParameter::LogParameter(const LogParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&shift_, &from.shift_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&shift_)) + sizeof(scale_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.LogParameter)
}

void LogParameter::SharedCtor() {
  _cached_size_ = 0;
  shift_ = 0;
  base_ = -1;
  scale_ = 1;
}

LogParameter::~LogParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.LogParameter)
  SharedDtor();
}

void LogParameter::SharedDtor() {
}

void LogParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LogParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const LogParameter& LogParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLogParameter();
  return *internal_default_instance();
}

LogParameter* LogParameter::New(::google::protobuf::Arena* arena) const {
  LogParameter* n = new LogParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void LogParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.LogParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    shift_ = 0;
    base_ = -1;
    scale_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool LogParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.LogParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float base = 1 [default = -1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_base();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &base_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float shift = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_shift();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &shift_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.LogParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.LogParameter)
  return false;
#undef DO_
}

void LogParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.LogParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float base = 1 [default = -1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->base(), output);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output);
  }

  // optional float shift = 3 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->shift(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.LogParameter)
}

::google::protobuf::uint8* LogParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LogParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float base = 1 [default = -1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->base(), target);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target);
  }

  // optional float shift = 3 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->shift(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LogParameter)
  return target;
}

size_t LogParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LogParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional float shift = 3 [default = 0];
    if (has_shift()) {
      total_size += 1 + 4;
    }

    // optional float base = 1 [default = -1];
    if (has_base()) {
      total_size += 1 + 4;
    }

    // optional float scale = 2 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LogParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.LogParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const LogParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const LogParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.LogParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.LogParameter)
    MergeFrom(*source);
  }
}

void LogParameter::MergeFrom(const LogParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LogParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      shift_ = from.shift_;
    }
    if (cached_has_bits & 0x00000002u) {
      base_ = from.base_;
    }
    if (cached_has_bits & 0x00000004u) {
      scale_ = from.scale_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LogParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.LogParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LogParameter::CopyFrom(const LogParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LogParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LogParameter::IsInitialized() const {
  return true;
}

void LogParameter::Swap(LogParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LogParameter::InternalSwap(LogParameter* other) {
  using std::swap;
  swap(shift_, other->shift_);
  swap(base_, other->base_);
  swap(scale_, other->scale_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata LogParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void LRNParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int LRNParameter::kLocalSizeFieldNumber;
const int LRNParameter::kAlphaFieldNumber;
const int LRNParameter::kBetaFieldNumber;
const int LRNParameter::kNormRegionFieldNumber;
const int LRNParameter::kKFieldNumber;
const int LRNParameter::kEngineFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

LRNParameter::LRNParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLRNParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.LRNParameter)
}
LRNParameter::LRNParameter(const LRNParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&norm_region_, &from.norm_region_,
    static_cast<size_t>(reinterpret_cast<char*>(&k_) -
    reinterpret_cast<char*>(&norm_region_)) + sizeof(k_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.LRNParameter)
}

void LRNParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&norm_region_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&engine_) -
      reinterpret_cast<char*>(&norm_region_)) + sizeof(engine_));
  local_size_ = 5u;
  alpha_ = 1;
  beta_ = 0.75f;
  k_ = 1;
}

LRNParameter::~LRNParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.LRNParameter)
  SharedDtor();
}

void LRNParameter::SharedDtor() {
}

void LRNParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* LRNParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const LRNParameter& LRNParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsLRNParameter();
  return *internal_default_instance();
}

LRNParameter* LRNParameter::New(::google::protobuf::Arena* arena) const {
  LRNParameter* n = new LRNParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void LRNParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.LRNParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 63u) {
    ::memset(&norm_region_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&engine_) -
        reinterpret_cast<char*>(&norm_region_)) + sizeof(engine_));
    local_size_ = 5u;
    alpha_ = 1;
    beta_ = 0.75f;
    k_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool LRNParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.LRNParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 local_size = 1 [default = 5];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_local_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &local_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float alpha = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_alpha();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &alpha_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float beta = 3 [default = 0.75];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_beta();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &beta_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::LRNParameter_NormRegion_IsValid(value)) {
            set_norm_region(static_cast< ::opencv_caffe::LRNParameter_NormRegion >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                4, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float k = 5 [default = 1];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          set_has_k();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &k_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::LRNParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::LRNParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                6, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.LRNParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.LRNParameter)
  return false;
#undef DO_
}

void LRNParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.LRNParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 local_size = 1 [default = 5];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->local_size(), output);
  }

  // optional float alpha = 2 [default = 1];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->alpha(), output);
  }

  // optional float beta = 3 [default = 0.75];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->beta(), output);
  }

  // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->norm_region(), output);
  }

  // optional float k = 5 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->k(), output);
  }

  // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->engine(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.LRNParameter)
}

::google::protobuf::uint8* LRNParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.LRNParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 local_size = 1 [default = 5];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->local_size(), target);
  }

  // optional float alpha = 2 [default = 1];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->alpha(), target);
  }

  // optional float beta = 3 [default = 0.75];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->beta(), target);
  }

  // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->norm_region(), target);
  }

  // optional float k = 5 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->k(), target);
  }

  // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      6, this->engine(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.LRNParameter)
  return target;
}

size_t LRNParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.LRNParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 63u) {
    // optional .opencv_caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
    if (has_norm_region()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->norm_region());
    }

    // optional .opencv_caffe.LRNParameter.Engine engine = 6 [default = DEFAULT];
    if (has_engine()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
    }

    // optional uint32 local_size = 1 [default = 5];
    if (has_local_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->local_size());
    }

    // optional float alpha = 2 [default = 1];
    if (has_alpha()) {
      total_size += 1 + 4;
    }

    // optional float beta = 3 [default = 0.75];
    if (has_beta()) {
      total_size += 1 + 4;
    }

    // optional float k = 5 [default = 1];
    if (has_k()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LRNParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.LRNParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const LRNParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const LRNParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.LRNParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.LRNParameter)
    MergeFrom(*source);
  }
}

void LRNParameter::MergeFrom(const LRNParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.LRNParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      norm_region_ = from.norm_region_;
    }
    if (cached_has_bits & 0x00000002u) {
      engine_ = from.engine_;
    }
    if (cached_has_bits & 0x00000004u) {
      local_size_ = from.local_size_;
    }
    if (cached_has_bits & 0x00000008u) {
      alpha_ = from.alpha_;
    }
    if (cached_has_bits & 0x00000010u) {
      beta_ = from.beta_;
    }
    if (cached_has_bits & 0x00000020u) {
      k_ = from.k_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LRNParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.LRNParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LRNParameter::CopyFrom(const LRNParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.LRNParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LRNParameter::IsInitialized() const {
  return true;
}

void LRNParameter::Swap(LRNParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LRNParameter::InternalSwap(LRNParameter* other) {
  using std::swap;
  swap(norm_region_, other->norm_region_);
  swap(engine_, other->engine_);
  swap(local_size_, other->local_size_);
  swap(alpha_, other->alpha_);
  swap(beta_, other->beta_);
  swap(k_, other->k_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata LRNParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void MemoryDataParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int MemoryDataParameter::kBatchSizeFieldNumber;
const int MemoryDataParameter::kChannelsFieldNumber;
const int MemoryDataParameter::kHeightFieldNumber;
const int MemoryDataParameter::kWidthFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

MemoryDataParameter::MemoryDataParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsMemoryDataParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.MemoryDataParameter)
}
MemoryDataParameter::MemoryDataParameter(const MemoryDataParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&batch_size_, &from.batch_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&width_) -
    reinterpret_cast<char*>(&batch_size_)) + sizeof(width_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.MemoryDataParameter)
}

void MemoryDataParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&batch_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&width_) -
      reinterpret_cast<char*>(&batch_size_)) + sizeof(width_));
}

MemoryDataParameter::~MemoryDataParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.MemoryDataParameter)
  SharedDtor();
}

void MemoryDataParameter::SharedDtor() {
}

void MemoryDataParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MemoryDataParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const MemoryDataParameter& MemoryDataParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsMemoryDataParameter();
  return *internal_default_instance();
}

MemoryDataParameter* MemoryDataParameter::New(::google::protobuf::Arena* arena) const {
  MemoryDataParameter* n = new MemoryDataParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void MemoryDataParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.MemoryDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 15u) {
    ::memset(&batch_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&width_) -
        reinterpret_cast<char*>(&batch_size_)) + sizeof(width_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool MemoryDataParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.MemoryDataParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 batch_size = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_batch_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &batch_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 channels = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 height = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 width = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.MemoryDataParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.MemoryDataParameter)
  return false;
#undef DO_
}

void MemoryDataParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.MemoryDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 batch_size = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->batch_size(), output);
  }

  // optional uint32 channels = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->channels(), output);
  }

  // optional uint32 height = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->height(), output);
  }

  // optional uint32 width = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->width(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.MemoryDataParameter)
}

::google::protobuf::uint8* MemoryDataParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.MemoryDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 batch_size = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->batch_size(), target);
  }

  // optional uint32 channels = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->channels(), target);
  }

  // optional uint32 height = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->height(), target);
  }

  // optional uint32 width = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->width(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.MemoryDataParameter)
  return target;
}

size_t MemoryDataParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.MemoryDataParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional uint32 batch_size = 1;
    if (has_batch_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->batch_size());
    }

    // optional uint32 channels = 2;
    if (has_channels()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->channels());
    }

    // optional uint32 height = 3;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->height());
    }

    // optional uint32 width = 4;
    if (has_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->width());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MemoryDataParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.MemoryDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const MemoryDataParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const MemoryDataParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.MemoryDataParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.MemoryDataParameter)
    MergeFrom(*source);
  }
}

void MemoryDataParameter::MergeFrom(const MemoryDataParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.MemoryDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      batch_size_ = from.batch_size_;
    }
    if (cached_has_bits & 0x00000002u) {
      channels_ = from.channels_;
    }
    if (cached_has_bits & 0x00000004u) {
      height_ = from.height_;
    }
    if (cached_has_bits & 0x00000008u) {
      width_ = from.width_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void MemoryDataParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.MemoryDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MemoryDataParameter::CopyFrom(const MemoryDataParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.MemoryDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MemoryDataParameter::IsInitialized() const {
  return true;
}

void MemoryDataParameter::Swap(MemoryDataParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void MemoryDataParameter::InternalSwap(MemoryDataParameter* other) {
  using std::swap;
  swap(batch_size_, other->batch_size_);
  swap(channels_, other->channels_);
  swap(height_, other->height_);
  swap(width_, other->width_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata MemoryDataParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void MVNParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int MVNParameter::kNormalizeVarianceFieldNumber;
const int MVNParameter::kAcrossChannelsFieldNumber;
const int MVNParameter::kEpsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

MVNParameter::MVNParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsMVNParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.MVNParameter)
}
MVNParameter::MVNParameter(const MVNParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&across_channels_, &from.across_channels_,
    static_cast<size_t>(reinterpret_cast<char*>(&eps_) -
    reinterpret_cast<char*>(&across_channels_)) + sizeof(eps_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.MVNParameter)
}

void MVNParameter::SharedCtor() {
  _cached_size_ = 0;
  across_channels_ = false;
  normalize_variance_ = true;
  eps_ = 1e-09f;
}

MVNParameter::~MVNParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.MVNParameter)
  SharedDtor();
}

void MVNParameter::SharedDtor() {
}

void MVNParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MVNParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const MVNParameter& MVNParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsMVNParameter();
  return *internal_default_instance();
}

MVNParameter* MVNParameter::New(::google::protobuf::Arena* arena) const {
  MVNParameter* n = new MVNParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void MVNParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.MVNParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    across_channels_ = false;
    normalize_variance_ = true;
    eps_ = 1e-09f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool MVNParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.MVNParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool normalize_variance = 1 [default = true];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_normalize_variance();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &normalize_variance_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool across_channels = 2 [default = false];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_across_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &across_channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float eps = 3 [default = 1e-09];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_eps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &eps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.MVNParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.MVNParameter)
  return false;
#undef DO_
}

void MVNParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.MVNParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool normalize_variance = 1 [default = true];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->normalize_variance(), output);
  }

  // optional bool across_channels = 2 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->across_channels(), output);
  }

  // optional float eps = 3 [default = 1e-09];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->eps(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.MVNParameter)
}

::google::protobuf::uint8* MVNParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.MVNParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool normalize_variance = 1 [default = true];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->normalize_variance(), target);
  }

  // optional bool across_channels = 2 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->across_channels(), target);
  }

  // optional float eps = 3 [default = 1e-09];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->eps(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.MVNParameter)
  return target;
}

size_t MVNParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.MVNParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional bool across_channels = 2 [default = false];
    if (has_across_channels()) {
      total_size += 1 + 1;
    }

    // optional bool normalize_variance = 1 [default = true];
    if (has_normalize_variance()) {
      total_size += 1 + 1;
    }

    // optional float eps = 3 [default = 1e-09];
    if (has_eps()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MVNParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.MVNParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const MVNParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const MVNParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.MVNParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.MVNParameter)
    MergeFrom(*source);
  }
}

void MVNParameter::MergeFrom(const MVNParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.MVNParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      across_channels_ = from.across_channels_;
    }
    if (cached_has_bits & 0x00000002u) {
      normalize_variance_ = from.normalize_variance_;
    }
    if (cached_has_bits & 0x00000004u) {
      eps_ = from.eps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void MVNParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.MVNParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MVNParameter::CopyFrom(const MVNParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.MVNParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MVNParameter::IsInitialized() const {
  return true;
}

void MVNParameter::Swap(MVNParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void MVNParameter::InternalSwap(MVNParameter* other) {
  using std::swap;
  swap(across_channels_, other->across_channels_);
  swap(normalize_variance_, other->normalize_variance_);
  swap(eps_, other->eps_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata MVNParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ParameterParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_ParameterParameter_default_instance_._instance.get_mutable()->shape_ = const_cast< ::opencv_caffe::BlobShape*>(
      ::opencv_caffe::BlobShape::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ParameterParameter::kShapeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ParameterParameter::ParameterParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsParameterParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ParameterParameter)
}
ParameterParameter::ParameterParameter(const ParameterParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_shape()) {
    shape_ = new ::opencv_caffe::BlobShape(*from.shape_);
  } else {
    shape_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ParameterParameter)
}

void ParameterParameter::SharedCtor() {
  _cached_size_ = 0;
  shape_ = NULL;
}

ParameterParameter::~ParameterParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ParameterParameter)
  SharedDtor();
}

void ParameterParameter::SharedDtor() {
  if (this != internal_default_instance()) delete shape_;
}

void ParameterParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ParameterParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ParameterParameter& ParameterParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsParameterParameter();
  return *internal_default_instance();
}

ParameterParameter* ParameterParameter::New(::google::protobuf::Arena* arena) const {
  ParameterParameter* n = new ParameterParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ParameterParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ParameterParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(shape_ != NULL);
    shape_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ParameterParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ParameterParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.BlobShape shape = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_shape()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ParameterParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ParameterParameter)
  return false;
#undef DO_
}

void ParameterParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ParameterParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.BlobShape shape = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->shape_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ParameterParameter)
}

::google::protobuf::uint8* ParameterParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ParameterParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.BlobShape shape = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->shape_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ParameterParameter)
  return target;
}

size_t ParameterParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ParameterParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .opencv_caffe.BlobShape shape = 1;
  if (has_shape()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->shape_);
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ParameterParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ParameterParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ParameterParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ParameterParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ParameterParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ParameterParameter)
    MergeFrom(*source);
  }
}

void ParameterParameter::MergeFrom(const ParameterParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ParameterParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_shape()) {
    mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from.shape());
  }
}

void ParameterParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ParameterParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ParameterParameter::CopyFrom(const ParameterParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ParameterParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ParameterParameter::IsInitialized() const {
  return true;
}

void ParameterParameter::Swap(ParameterParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ParameterParameter::InternalSwap(ParameterParameter* other) {
  using std::swap;
  swap(shape_, other->shape_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ParameterParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PoolingParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PoolingParameter::kPoolFieldNumber;
const int PoolingParameter::kPadFieldNumber;
const int PoolingParameter::kPadHFieldNumber;
const int PoolingParameter::kPadWFieldNumber;
const int PoolingParameter::kKernelSizeFieldNumber;
const int PoolingParameter::kKernelHFieldNumber;
const int PoolingParameter::kKernelWFieldNumber;
const int PoolingParameter::kStrideFieldNumber;
const int PoolingParameter::kStrideHFieldNumber;
const int PoolingParameter::kStrideWFieldNumber;
const int PoolingParameter::kEngineFieldNumber;
const int PoolingParameter::kGlobalPoolingFieldNumber;
const int PoolingParameter::kCeilModeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PoolingParameter::PoolingParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPoolingParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PoolingParameter)
}
PoolingParameter::PoolingParameter(const PoolingParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&pool_, &from.pool_,
    static_cast<size_t>(reinterpret_cast<char*>(&ceil_mode_) -
    reinterpret_cast<char*>(&pool_)) + sizeof(ceil_mode_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PoolingParameter)
}

void PoolingParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&pool_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&global_pooling_) -
      reinterpret_cast<char*>(&pool_)) + sizeof(global_pooling_));
  stride_ = 1u;
  ceil_mode_ = true;
}

PoolingParameter::~PoolingParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PoolingParameter)
  SharedDtor();
}

void PoolingParameter::SharedDtor() {
}

void PoolingParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PoolingParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PoolingParameter& PoolingParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPoolingParameter();
  return *internal_default_instance();
}

PoolingParameter* PoolingParameter::New(::google::protobuf::Arena* arena) const {
  PoolingParameter* n = new PoolingParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PoolingParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    ::memset(&pool_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&pad_h_) -
        reinterpret_cast<char*>(&pool_)) + sizeof(pad_h_));
  }
  if (cached_has_bits & 7936u) {
    ::memset(&pad_w_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&global_pooling_) -
        reinterpret_cast<char*>(&pad_w_)) + sizeof(global_pooling_));
    stride_ = 1u;
    ceil_mode_ = true;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PoolingParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PoolingParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::PoolingParameter_PoolMethod_IsValid(value)) {
            set_pool(static_cast< ::opencv_caffe::PoolingParameter_PoolMethod >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 kernel_size = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_kernel_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kernel_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 stride = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_stride();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stride_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pad = 4 [default = 0];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_pad();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pad_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 kernel_h = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_kernel_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kernel_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 kernel_w = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_kernel_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kernel_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 stride_h = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_stride_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stride_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 stride_w = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          set_has_stride_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stride_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pad_h = 9 [default = 0];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_pad_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pad_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pad_w = 10 [default = 0];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_pad_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pad_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::PoolingParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::PoolingParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                11, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool global_pooling = 12 [default = false];
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) {
          set_has_global_pooling();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &global_pooling_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool ceil_mode = 13 [default = true];
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) {
          set_has_ceil_mode();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ceil_mode_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PoolingParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PoolingParameter)
  return false;
#undef DO_
}

void PoolingParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->pool(), output);
  }

  // optional uint32 kernel_size = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->kernel_size(), output);
  }

  // optional uint32 stride = 3 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stride(), output);
  }

  // optional uint32 pad = 4 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->pad(), output);
  }

  // optional uint32 kernel_h = 5;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->kernel_h(), output);
  }

  // optional uint32 kernel_w = 6;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->kernel_w(), output);
  }

  // optional uint32 stride_h = 7;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->stride_h(), output);
  }

  // optional uint32 stride_w = 8;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->stride_w(), output);
  }

  // optional uint32 pad_h = 9 [default = 0];
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->pad_h(), output);
  }

  // optional uint32 pad_w = 10 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->pad_w(), output);
  }

  // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      11, this->engine(), output);
  }

  // optional bool global_pooling = 12 [default = false];
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->global_pooling(), output);
  }

  // optional bool ceil_mode = 13 [default = true];
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->ceil_mode(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PoolingParameter)
}

::google::protobuf::uint8* PoolingParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->pool(), target);
  }

  // optional uint32 kernel_size = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->kernel_size(), target);
  }

  // optional uint32 stride = 3 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->stride(), target);
  }

  // optional uint32 pad = 4 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->pad(), target);
  }

  // optional uint32 kernel_h = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->kernel_h(), target);
  }

  // optional uint32 kernel_w = 6;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->kernel_w(), target);
  }

  // optional uint32 stride_h = 7;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->stride_h(), target);
  }

  // optional uint32 stride_w = 8;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->stride_w(), target);
  }

  // optional uint32 pad_h = 9 [default = 0];
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->pad_h(), target);
  }

  // optional uint32 pad_w = 10 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->pad_w(), target);
  }

  // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      11, this->engine(), target);
  }

  // optional bool global_pooling = 12 [default = false];
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->global_pooling(), target);
  }

  // optional bool ceil_mode = 13 [default = true];
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->ceil_mode(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PoolingParameter)
  return target;
}

size_t PoolingParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PoolingParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional .opencv_caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
    if (has_pool()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->pool());
    }

    // optional uint32 kernel_size = 2;
    if (has_kernel_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kernel_size());
    }

    // optional uint32 pad = 4 [default = 0];
    if (has_pad()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pad());
    }

    // optional uint32 kernel_h = 5;
    if (has_kernel_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kernel_h());
    }

    // optional uint32 kernel_w = 6;
    if (has_kernel_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kernel_w());
    }

    // optional uint32 stride_h = 7;
    if (has_stride_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stride_h());
    }

    // optional uint32 stride_w = 8;
    if (has_stride_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stride_w());
    }

    // optional uint32 pad_h = 9 [default = 0];
    if (has_pad_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pad_h());
    }

  }
  if (_has_bits_[8 / 32] & 7936u) {
    // optional uint32 pad_w = 10 [default = 0];
    if (has_pad_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pad_w());
    }

    // optional .opencv_caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
    if (has_engine()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
    }

    // optional bool global_pooling = 12 [default = false];
    if (has_global_pooling()) {
      total_size += 1 + 1;
    }

    // optional uint32 stride = 3 [default = 1];
    if (has_stride()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stride());
    }

    // optional bool ceil_mode = 13 [default = true];
    if (has_ceil_mode()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PoolingParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PoolingParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PoolingParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PoolingParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PoolingParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PoolingParameter)
    MergeFrom(*source);
  }
}

void PoolingParameter::MergeFrom(const PoolingParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PoolingParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      pool_ = from.pool_;
    }
    if (cached_has_bits & 0x00000002u) {
      kernel_size_ = from.kernel_size_;
    }
    if (cached_has_bits & 0x00000004u) {
      pad_ = from.pad_;
    }
    if (cached_has_bits & 0x00000008u) {
      kernel_h_ = from.kernel_h_;
    }
    if (cached_has_bits & 0x00000010u) {
      kernel_w_ = from.kernel_w_;
    }
    if (cached_has_bits & 0x00000020u) {
      stride_h_ = from.stride_h_;
    }
    if (cached_has_bits & 0x00000040u) {
      stride_w_ = from.stride_w_;
    }
    if (cached_has_bits & 0x00000080u) {
      pad_h_ = from.pad_h_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 7936u) {
    if (cached_has_bits & 0x00000100u) {
      pad_w_ = from.pad_w_;
    }
    if (cached_has_bits & 0x00000200u) {
      engine_ = from.engine_;
    }
    if (cached_has_bits & 0x00000400u) {
      global_pooling_ = from.global_pooling_;
    }
    if (cached_has_bits & 0x00000800u) {
      stride_ = from.stride_;
    }
    if (cached_has_bits & 0x00001000u) {
      ceil_mode_ = from.ceil_mode_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PoolingParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PoolingParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PoolingParameter::CopyFrom(const PoolingParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PoolingParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PoolingParameter::IsInitialized() const {
  return true;
}

void PoolingParameter::Swap(PoolingParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PoolingParameter::InternalSwap(PoolingParameter* other) {
  using std::swap;
  swap(pool_, other->pool_);
  swap(kernel_size_, other->kernel_size_);
  swap(pad_, other->pad_);
  swap(kernel_h_, other->kernel_h_);
  swap(kernel_w_, other->kernel_w_);
  swap(stride_h_, other->stride_h_);
  swap(stride_w_, other->stride_w_);
  swap(pad_h_, other->pad_h_);
  swap(pad_w_, other->pad_w_);
  swap(engine_, other->engine_);
  swap(global_pooling_, other->global_pooling_);
  swap(stride_, other->stride_);
  swap(ceil_mode_, other->ceil_mode_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PoolingParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PowerParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PowerParameter::kPowerFieldNumber;
const int PowerParameter::kScaleFieldNumber;
const int PowerParameter::kShiftFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PowerParameter::PowerParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPowerParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PowerParameter)
}
PowerParameter::PowerParameter(const PowerParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&shift_, &from.shift_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&shift_)) + sizeof(scale_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PowerParameter)
}

void PowerParameter::SharedCtor() {
  _cached_size_ = 0;
  shift_ = 0;
  power_ = 1;
  scale_ = 1;
}

PowerParameter::~PowerParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PowerParameter)
  SharedDtor();
}

void PowerParameter::SharedDtor() {
}

void PowerParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PowerParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PowerParameter& PowerParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPowerParameter();
  return *internal_default_instance();
}

PowerParameter* PowerParameter::New(::google::protobuf::Arena* arena) const {
  PowerParameter* n = new PowerParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PowerParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PowerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    shift_ = 0;
    power_ = 1;
    scale_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PowerParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PowerParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float power = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_power();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &power_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float shift = 3 [default = 0];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_shift();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &shift_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PowerParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PowerParameter)
  return false;
#undef DO_
}

void PowerParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PowerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float power = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->power(), output);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output);
  }

  // optional float shift = 3 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->shift(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PowerParameter)
}

::google::protobuf::uint8* PowerParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PowerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float power = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->power(), target);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target);
  }

  // optional float shift = 3 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->shift(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PowerParameter)
  return target;
}

size_t PowerParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PowerParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional float shift = 3 [default = 0];
    if (has_shift()) {
      total_size += 1 + 4;
    }

    // optional float power = 1 [default = 1];
    if (has_power()) {
      total_size += 1 + 4;
    }

    // optional float scale = 2 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PowerParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PowerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PowerParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PowerParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PowerParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PowerParameter)
    MergeFrom(*source);
  }
}

void PowerParameter::MergeFrom(const PowerParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PowerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      shift_ = from.shift_;
    }
    if (cached_has_bits & 0x00000002u) {
      power_ = from.power_;
    }
    if (cached_has_bits & 0x00000004u) {
      scale_ = from.scale_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PowerParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PowerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PowerParameter::CopyFrom(const PowerParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PowerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PowerParameter::IsInitialized() const {
  return true;
}

void PowerParameter::Swap(PowerParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PowerParameter::InternalSwap(PowerParameter* other) {
  using std::swap;
  swap(shift_, other->shift_);
  swap(power_, other->power_);
  swap(scale_, other->scale_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PowerParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PythonParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PythonParameter::kModuleFieldNumber;
const int PythonParameter::kLayerFieldNumber;
const int PythonParameter::kParamStrFieldNumber;
const int PythonParameter::kShareInParallelFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PythonParameter::PythonParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPythonParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PythonParameter)
}
PythonParameter::PythonParameter(const PythonParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  module_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_module()) {
    module_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.module_);
  }
  layer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_layer()) {
    layer_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.layer_);
  }
  param_str_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_param_str()) {
    param_str_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.param_str_);
  }
  share_in_parallel_ = from.share_in_parallel_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PythonParameter)
}

void PythonParameter::SharedCtor() {
  _cached_size_ = 0;
  module_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  layer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  param_str_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  share_in_parallel_ = false;
}

PythonParameter::~PythonParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PythonParameter)
  SharedDtor();
}

void PythonParameter::SharedDtor() {
  module_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  layer_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  param_str_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void PythonParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PythonParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PythonParameter& PythonParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPythonParameter();
  return *internal_default_instance();
}

PythonParameter* PythonParameter::New(::google::protobuf::Arena* arena) const {
  PythonParameter* n = new PythonParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PythonParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PythonParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!module_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*module_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!layer_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*layer_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(!param_str_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*param_str_.UnsafeRawStringPointer())->clear();
    }
  }
  share_in_parallel_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PythonParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PythonParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string module = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_module()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->module().data(), static_cast<int>(this->module().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.PythonParameter.module");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string layer = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_layer()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->layer().data(), static_cast<int>(this->layer().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.PythonParameter.layer");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string param_str = 3 [default = ""];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_param_str()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->param_str().data(), static_cast<int>(this->param_str().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.PythonParameter.param_str");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool share_in_parallel = 4 [default = false];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_share_in_parallel();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &share_in_parallel_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PythonParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PythonParameter)
  return false;
#undef DO_
}

void PythonParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PythonParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string module = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->module().data(), static_cast<int>(this->module().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.PythonParameter.module");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->module(), output);
  }

  // optional string layer = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->layer().data(), static_cast<int>(this->layer().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.PythonParameter.layer");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->layer(), output);
  }

  // optional string param_str = 3 [default = ""];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->param_str().data(), static_cast<int>(this->param_str().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.PythonParameter.param_str");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->param_str(), output);
  }

  // optional bool share_in_parallel = 4 [default = false];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->share_in_parallel(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PythonParameter)
}

::google::protobuf::uint8* PythonParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PythonParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string module = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->module().data(), static_cast<int>(this->module().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.PythonParameter.module");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->module(), target);
  }

  // optional string layer = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->layer().data(), static_cast<int>(this->layer().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.PythonParameter.layer");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->layer(), target);
  }

  // optional string param_str = 3 [default = ""];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->param_str().data(), static_cast<int>(this->param_str().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.PythonParameter.param_str");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->param_str(), target);
  }

  // optional bool share_in_parallel = 4 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->share_in_parallel(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PythonParameter)
  return target;
}

size_t PythonParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PythonParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional string module = 1;
    if (has_module()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->module());
    }

    // optional string layer = 2;
    if (has_layer()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->layer());
    }

    // optional string param_str = 3 [default = ""];
    if (has_param_str()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->param_str());
    }

    // optional bool share_in_parallel = 4 [default = false];
    if (has_share_in_parallel()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PythonParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PythonParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PythonParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PythonParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PythonParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PythonParameter)
    MergeFrom(*source);
  }
}

void PythonParameter::MergeFrom(const PythonParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PythonParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_module();
      module_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.module_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_layer();
      layer_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.layer_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_param_str();
      param_str_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.param_str_);
    }
    if (cached_has_bits & 0x00000008u) {
      share_in_parallel_ = from.share_in_parallel_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PythonParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PythonParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PythonParameter::CopyFrom(const PythonParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PythonParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PythonParameter::IsInitialized() const {
  return true;
}

void PythonParameter::Swap(PythonParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PythonParameter::InternalSwap(PythonParameter* other) {
  using std::swap;
  module_.Swap(&other->module_);
  layer_.Swap(&other->layer_);
  param_str_.Swap(&other->param_str_);
  swap(share_in_parallel_, other->share_in_parallel_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PythonParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RecurrentParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_RecurrentParameter_default_instance_._instance.get_mutable()->weight_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_RecurrentParameter_default_instance_._instance.get_mutable()->bias_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RecurrentParameter::kNumOutputFieldNumber;
const int RecurrentParameter::kWeightFillerFieldNumber;
const int RecurrentParameter::kBiasFillerFieldNumber;
const int RecurrentParameter::kDebugInfoFieldNumber;
const int RecurrentParameter::kExposeHiddenFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RecurrentParameter::RecurrentParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsRecurrentParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.RecurrentParameter)
}
RecurrentParameter::RecurrentParameter(const RecurrentParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_weight_filler()) {
    weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_);
  } else {
    weight_filler_ = NULL;
  }
  if (from.has_bias_filler()) {
    bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_);
  } else {
    bias_filler_ = NULL;
  }
  ::memcpy(&num_output_, &from.num_output_,
    static_cast<size_t>(reinterpret_cast<char*>(&expose_hidden_) -
    reinterpret_cast<char*>(&num_output_)) + sizeof(expose_hidden_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.RecurrentParameter)
}

void RecurrentParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&weight_filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&expose_hidden_) -
      reinterpret_cast<char*>(&weight_filler_)) + sizeof(expose_hidden_));
}

RecurrentParameter::~RecurrentParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.RecurrentParameter)
  SharedDtor();
}

void RecurrentParameter::SharedDtor() {
  if (this != internal_default_instance()) delete weight_filler_;
  if (this != internal_default_instance()) delete bias_filler_;
}

void RecurrentParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RecurrentParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RecurrentParameter& RecurrentParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsRecurrentParameter();
  return *internal_default_instance();
}

RecurrentParameter* RecurrentParameter::New(::google::protobuf::Arena* arena) const {
  RecurrentParameter* n = new RecurrentParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RecurrentParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.RecurrentParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(weight_filler_ != NULL);
      weight_filler_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(bias_filler_ != NULL);
      bias_filler_->Clear();
    }
  }
  if (cached_has_bits & 28u) {
    ::memset(&num_output_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&expose_hidden_) -
        reinterpret_cast<char*>(&num_output_)) + sizeof(expose_hidden_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RecurrentParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.RecurrentParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_output = 1 [default = 0];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_num_output();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_output_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter weight_filler = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_weight_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter bias_filler = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool debug_info = 4 [default = false];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_debug_info();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &debug_info_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool expose_hidden = 5 [default = false];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_expose_hidden();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &expose_hidden_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.RecurrentParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.RecurrentParameter)
  return false;
#undef DO_
}

void RecurrentParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.RecurrentParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_output(), output);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->weight_filler_, output);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->bias_filler_, output);
  }

  // optional bool debug_info = 4 [default = false];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->debug_info(), output);
  }

  // optional bool expose_hidden = 5 [default = false];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->expose_hidden(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.RecurrentParameter)
}

::google::protobuf::uint8* RecurrentParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.RecurrentParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 num_output = 1 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_output(), target);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->weight_filler_, deterministic, target);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, *this->bias_filler_, deterministic, target);
  }

  // optional bool debug_info = 4 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->debug_info(), target);
  }

  // optional bool expose_hidden = 5 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->expose_hidden(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.RecurrentParameter)
  return target;
}

size_t RecurrentParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.RecurrentParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 31u) {
    // optional .opencv_caffe.FillerParameter weight_filler = 2;
    if (has_weight_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->weight_filler_);
    }

    // optional .opencv_caffe.FillerParameter bias_filler = 3;
    if (has_bias_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_filler_);
    }

    // optional uint32 num_output = 1 [default = 0];
    if (has_num_output()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_output());
    }

    // optional bool debug_info = 4 [default = false];
    if (has_debug_info()) {
      total_size += 1 + 1;
    }

    // optional bool expose_hidden = 5 [default = false];
    if (has_expose_hidden()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RecurrentParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.RecurrentParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const RecurrentParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RecurrentParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.RecurrentParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.RecurrentParameter)
    MergeFrom(*source);
  }
}

void RecurrentParameter::MergeFrom(const RecurrentParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.RecurrentParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.weight_filler());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.bias_filler());
    }
    if (cached_has_bits & 0x00000004u) {
      num_output_ = from.num_output_;
    }
    if (cached_has_bits & 0x00000008u) {
      debug_info_ = from.debug_info_;
    }
    if (cached_has_bits & 0x00000010u) {
      expose_hidden_ = from.expose_hidden_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RecurrentParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.RecurrentParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RecurrentParameter::CopyFrom(const RecurrentParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.RecurrentParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecurrentParameter::IsInitialized() const {
  return true;
}

void RecurrentParameter::Swap(RecurrentParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RecurrentParameter::InternalSwap(RecurrentParameter* other) {
  using std::swap;
  swap(weight_filler_, other->weight_filler_);
  swap(bias_filler_, other->bias_filler_);
  swap(num_output_, other->num_output_);
  swap(debug_info_, other->debug_info_);
  swap(expose_hidden_, other->expose_hidden_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RecurrentParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ReductionParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ReductionParameter::kOperationFieldNumber;
const int ReductionParameter::kAxisFieldNumber;
const int ReductionParameter::kCoeffFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ReductionParameter::ReductionParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReductionParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ReductionParameter)
}
ReductionParameter::ReductionParameter(const ReductionParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&axis_, &from.axis_,
    static_cast<size_t>(reinterpret_cast<char*>(&coeff_) -
    reinterpret_cast<char*>(&axis_)) + sizeof(coeff_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReductionParameter)
}

void ReductionParameter::SharedCtor() {
  _cached_size_ = 0;
  axis_ = 0;
  operation_ = 1;
  coeff_ = 1;
}

ReductionParameter::~ReductionParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ReductionParameter)
  SharedDtor();
}

void ReductionParameter::SharedDtor() {
}

void ReductionParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ReductionParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ReductionParameter& ReductionParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReductionParameter();
  return *internal_default_instance();
}

ReductionParameter* ReductionParameter::New(::google::protobuf::Arena* arena) const {
  ReductionParameter* n = new ReductionParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ReductionParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ReductionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    axis_ = 0;
    operation_ = 1;
    coeff_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ReductionParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ReductionParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::ReductionParameter_ReductionOp_IsValid(value)) {
            set_operation(static_cast< ::opencv_caffe::ReductionParameter_ReductionOp >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float coeff = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_coeff();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &coeff_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ReductionParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ReductionParameter)
  return false;
#undef DO_
}

void ReductionParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ReductionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->operation(), output);
  }

  // optional int32 axis = 2 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output);
  }

  // optional float coeff = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->coeff(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ReductionParameter)
}

::google::protobuf::uint8* ReductionParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReductionParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->operation(), target);
  }

  // optional int32 axis = 2 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target);
  }

  // optional float coeff = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->coeff(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReductionParameter)
  return target;
}

size_t ReductionParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReductionParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional int32 axis = 2 [default = 0];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional .opencv_caffe.ReductionParameter.ReductionOp operation = 1 [default = SUM];
    if (has_operation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation());
    }

    // optional float coeff = 3 [default = 1];
    if (has_coeff()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReductionParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ReductionParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ReductionParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ReductionParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ReductionParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ReductionParameter)
    MergeFrom(*source);
  }
}

void ReductionParameter::MergeFrom(const ReductionParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReductionParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00000002u) {
      operation_ = from.operation_;
    }
    if (cached_has_bits & 0x00000004u) {
      coeff_ = from.coeff_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ReductionParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ReductionParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ReductionParameter::CopyFrom(const ReductionParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReductionParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReductionParameter::IsInitialized() const {
  return true;
}

void ReductionParameter::Swap(ReductionParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ReductionParameter::InternalSwap(ReductionParameter* other) {
  using std::swap;
  swap(axis_, other->axis_);
  swap(operation_, other->operation_);
  swap(coeff_, other->coeff_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ReductionParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ReLUParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ReLUParameter::kNegativeSlopeFieldNumber;
const int ReLUParameter::kEngineFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ReLUParameter::ReLUParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReLUParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ReLUParameter)
}
ReLUParameter::ReLUParameter(const ReLUParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&negative_slope_, &from.negative_slope_,
    static_cast<size_t>(reinterpret_cast<char*>(&engine_) -
    reinterpret_cast<char*>(&negative_slope_)) + sizeof(engine_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReLUParameter)
}

void ReLUParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&negative_slope_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&engine_) -
      reinterpret_cast<char*>(&negative_slope_)) + sizeof(engine_));
}

ReLUParameter::~ReLUParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ReLUParameter)
  SharedDtor();
}

void ReLUParameter::SharedDtor() {
}

void ReLUParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ReLUParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ReLUParameter& ReLUParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReLUParameter();
  return *internal_default_instance();
}

ReLUParameter* ReLUParameter::New(::google::protobuf::Arena* arena) const {
  ReLUParameter* n = new ReLUParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ReLUParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ReLUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    ::memset(&negative_slope_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&engine_) -
        reinterpret_cast<char*>(&negative_slope_)) + sizeof(engine_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ReLUParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ReLUParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float negative_slope = 1 [default = 0];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_negative_slope();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &negative_slope_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::ReLUParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::ReLUParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ReLUParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ReLUParameter)
  return false;
#undef DO_
}

void ReLUParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ReLUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float negative_slope = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->negative_slope(), output);
  }

  // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->engine(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ReLUParameter)
}

::google::protobuf::uint8* ReLUParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReLUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float negative_slope = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->negative_slope(), target);
  }

  // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->engine(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReLUParameter)
  return target;
}

size_t ReLUParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReLUParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional float negative_slope = 1 [default = 0];
    if (has_negative_slope()) {
      total_size += 1 + 4;
    }

    // optional .opencv_caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
    if (has_engine()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReLUParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ReLUParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ReLUParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ReLUParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ReLUParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ReLUParameter)
    MergeFrom(*source);
  }
}

void ReLUParameter::MergeFrom(const ReLUParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReLUParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      negative_slope_ = from.negative_slope_;
    }
    if (cached_has_bits & 0x00000002u) {
      engine_ = from.engine_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ReLUParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ReLUParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ReLUParameter::CopyFrom(const ReLUParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReLUParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReLUParameter::IsInitialized() const {
  return true;
}

void ReLUParameter::Swap(ReLUParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ReLUParameter::InternalSwap(ReLUParameter* other) {
  using std::swap;
  swap(negative_slope_, other->negative_slope_);
  swap(engine_, other->engine_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ReLUParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ReshapeParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_ReshapeParameter_default_instance_._instance.get_mutable()->shape_ = const_cast< ::opencv_caffe::BlobShape*>(
      ::opencv_caffe::BlobShape::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ReshapeParameter::kShapeFieldNumber;
const int ReshapeParameter::kAxisFieldNumber;
const int ReshapeParameter::kNumAxesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ReshapeParameter::ReshapeParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReshapeParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ReshapeParameter)
}
ReshapeParameter::ReshapeParameter(const ReshapeParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_shape()) {
    shape_ = new ::opencv_caffe::BlobShape(*from.shape_);
  } else {
    shape_ = NULL;
  }
  ::memcpy(&axis_, &from.axis_,
    static_cast<size_t>(reinterpret_cast<char*>(&num_axes_) -
    reinterpret_cast<char*>(&axis_)) + sizeof(num_axes_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ReshapeParameter)
}

void ReshapeParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&shape_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&axis_) -
      reinterpret_cast<char*>(&shape_)) + sizeof(axis_));
  num_axes_ = -1;
}

ReshapeParameter::~ReshapeParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ReshapeParameter)
  SharedDtor();
}

void ReshapeParameter::SharedDtor() {
  if (this != internal_default_instance()) delete shape_;
}

void ReshapeParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ReshapeParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ReshapeParameter& ReshapeParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsReshapeParameter();
  return *internal_default_instance();
}

ReshapeParameter* ReshapeParameter::New(::google::protobuf::Arena* arena) const {
  ReshapeParameter* n = new ReshapeParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ReshapeParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ReshapeParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(shape_ != NULL);
    shape_->Clear();
  }
  if (cached_has_bits & 6u) {
    axis_ = 0;
    num_axes_ = -1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ReshapeParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ReshapeParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.BlobShape shape = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_shape()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 num_axes = 3 [default = -1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_num_axes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_axes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ReshapeParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ReshapeParameter)
  return false;
#undef DO_
}

void ReshapeParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ReshapeParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.BlobShape shape = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->shape_, output);
  }

  // optional int32 axis = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output);
  }

  // optional int32 num_axes = 3 [default = -1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->num_axes(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ReshapeParameter)
}

::google::protobuf::uint8* ReshapeParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ReshapeParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.BlobShape shape = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->shape_, deterministic, target);
  }

  // optional int32 axis = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target);
  }

  // optional int32 num_axes = 3 [default = -1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->num_axes(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ReshapeParameter)
  return target;
}

size_t ReshapeParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ReshapeParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional .opencv_caffe.BlobShape shape = 1;
    if (has_shape()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->shape_);
    }

    // optional int32 axis = 2 [default = 0];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional int32 num_axes = 3 [default = -1];
    if (has_num_axes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->num_axes());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReshapeParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ReshapeParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ReshapeParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ReshapeParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ReshapeParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ReshapeParameter)
    MergeFrom(*source);
  }
}

void ReshapeParameter::MergeFrom(const ReshapeParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ReshapeParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_shape()->::opencv_caffe::BlobShape::MergeFrom(from.shape());
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00000004u) {
      num_axes_ = from.num_axes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ReshapeParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ReshapeParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ReshapeParameter::CopyFrom(const ReshapeParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ReshapeParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReshapeParameter::IsInitialized() const {
  return true;
}

void ReshapeParameter::Swap(ReshapeParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ReshapeParameter::InternalSwap(ReshapeParameter* other) {
  using std::swap;
  swap(shape_, other->shape_);
  swap(axis_, other->axis_);
  swap(num_axes_, other->num_axes_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ReshapeParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ScaleParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_ScaleParameter_default_instance_._instance.get_mutable()->filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_ScaleParameter_default_instance_._instance.get_mutable()->bias_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ScaleParameter::kAxisFieldNumber;
const int ScaleParameter::kNumAxesFieldNumber;
const int ScaleParameter::kFillerFieldNumber;
const int ScaleParameter::kBiasTermFieldNumber;
const int ScaleParameter::kBiasFillerFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ScaleParameter::ScaleParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsScaleParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ScaleParameter)
}
ScaleParameter::ScaleParameter(const ScaleParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_filler()) {
    filler_ = new ::opencv_caffe::FillerParameter(*from.filler_);
  } else {
    filler_ = NULL;
  }
  if (from.has_bias_filler()) {
    bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_);
  } else {
    bias_filler_ = NULL;
  }
  ::memcpy(&bias_term_, &from.bias_term_,
    static_cast<size_t>(reinterpret_cast<char*>(&num_axes_) -
    reinterpret_cast<char*>(&bias_term_)) + sizeof(num_axes_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ScaleParameter)
}

void ScaleParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&bias_term_) -
      reinterpret_cast<char*>(&filler_)) + sizeof(bias_term_));
  axis_ = 1;
  num_axes_ = 1;
}

ScaleParameter::~ScaleParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ScaleParameter)
  SharedDtor();
}

void ScaleParameter::SharedDtor() {
  if (this != internal_default_instance()) delete filler_;
  if (this != internal_default_instance()) delete bias_filler_;
}

void ScaleParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ScaleParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ScaleParameter& ScaleParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsScaleParameter();
  return *internal_default_instance();
}

ScaleParameter* ScaleParameter::New(::google::protobuf::Arena* arena) const {
  ScaleParameter* n = new ScaleParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ScaleParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ScaleParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(filler_ != NULL);
      filler_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(bias_filler_ != NULL);
      bias_filler_->Clear();
    }
  }
  if (cached_has_bits & 28u) {
    bias_term_ = false;
    axis_ = 1;
    num_axes_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ScaleParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ScaleParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 axis = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 num_axes = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_num_axes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_axes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter filler = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool bias_term = 4 [default = false];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_bias_term();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &bias_term_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter bias_filler = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ScaleParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ScaleParameter)
  return false;
#undef DO_
}

void ScaleParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ScaleParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output);
  }

  // optional int32 num_axes = 2 [default = 1];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_axes(), output);
  }

  // optional .opencv_caffe.FillerParameter filler = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->filler_, output);
  }

  // optional bool bias_term = 4 [default = false];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->bias_term(), output);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 5;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->bias_filler_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ScaleParameter)
}

::google::protobuf::uint8* ScaleParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ScaleParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target);
  }

  // optional int32 num_axes = 2 [default = 1];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_axes(), target);
  }

  // optional .opencv_caffe.FillerParameter filler = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, *this->filler_, deterministic, target);
  }

  // optional bool bias_term = 4 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->bias_term(), target);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 5;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, *this->bias_filler_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ScaleParameter)
  return target;
}

size_t ScaleParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ScaleParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 31u) {
    // optional .opencv_caffe.FillerParameter filler = 3;
    if (has_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->filler_);
    }

    // optional .opencv_caffe.FillerParameter bias_filler = 5;
    if (has_bias_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_filler_);
    }

    // optional bool bias_term = 4 [default = false];
    if (has_bias_term()) {
      total_size += 1 + 1;
    }

    // optional int32 axis = 1 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

    // optional int32 num_axes = 2 [default = 1];
    if (has_num_axes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->num_axes());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ScaleParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ScaleParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ScaleParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ScaleParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ScaleParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ScaleParameter)
    MergeFrom(*source);
  }
}

void ScaleParameter::MergeFrom(const ScaleParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ScaleParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.filler());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.bias_filler());
    }
    if (cached_has_bits & 0x00000004u) {
      bias_term_ = from.bias_term_;
    }
    if (cached_has_bits & 0x00000008u) {
      axis_ = from.axis_;
    }
    if (cached_has_bits & 0x00000010u) {
      num_axes_ = from.num_axes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ScaleParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ScaleParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ScaleParameter::CopyFrom(const ScaleParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ScaleParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ScaleParameter::IsInitialized() const {
  return true;
}

void ScaleParameter::Swap(ScaleParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ScaleParameter::InternalSwap(ScaleParameter* other) {
  using std::swap;
  swap(filler_, other->filler_);
  swap(bias_filler_, other->bias_filler_);
  swap(bias_term_, other->bias_term_);
  swap(axis_, other->axis_);
  swap(num_axes_, other->num_axes_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ScaleParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SigmoidParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SigmoidParameter::kEngineFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SigmoidParameter::SigmoidParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSigmoidParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SigmoidParameter)
}
SigmoidParameter::SigmoidParameter(const SigmoidParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  engine_ = from.engine_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SigmoidParameter)
}

void SigmoidParameter::SharedCtor() {
  _cached_size_ = 0;
  engine_ = 0;
}

SigmoidParameter::~SigmoidParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SigmoidParameter)
  SharedDtor();
}

void SigmoidParameter::SharedDtor() {
}

void SigmoidParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SigmoidParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SigmoidParameter& SigmoidParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSigmoidParameter();
  return *internal_default_instance();
}

SigmoidParameter* SigmoidParameter::New(::google::protobuf::Arena* arena) const {
  SigmoidParameter* n = new SigmoidParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SigmoidParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SigmoidParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  engine_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SigmoidParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SigmoidParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SigmoidParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::SigmoidParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SigmoidParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SigmoidParameter)
  return false;
#undef DO_
}

void SigmoidParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SigmoidParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->engine(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SigmoidParameter)
}

::google::protobuf::uint8* SigmoidParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SigmoidParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->engine(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SigmoidParameter)
  return target;
}

size_t SigmoidParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SigmoidParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .opencv_caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
  if (has_engine()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SigmoidParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SigmoidParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const SigmoidParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SigmoidParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SigmoidParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SigmoidParameter)
    MergeFrom(*source);
  }
}

void SigmoidParameter::MergeFrom(const SigmoidParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SigmoidParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_engine()) {
    set_engine(from.engine());
  }
}

void SigmoidParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SigmoidParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SigmoidParameter::CopyFrom(const SigmoidParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SigmoidParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SigmoidParameter::IsInitialized() const {
  return true;
}

void SigmoidParameter::Swap(SigmoidParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SigmoidParameter::InternalSwap(SigmoidParameter* other) {
  using std::swap;
  swap(engine_, other->engine_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SigmoidParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SliceParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SliceParameter::kAxisFieldNumber;
const int SliceParameter::kSlicePointFieldNumber;
const int SliceParameter::kSliceDimFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SliceParameter::SliceParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSliceParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SliceParameter)
}
SliceParameter::SliceParameter(const SliceParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      slice_point_(from.slice_point_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&slice_dim_, &from.slice_dim_,
    static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
    reinterpret_cast<char*>(&slice_dim_)) + sizeof(axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SliceParameter)
}

void SliceParameter::SharedCtor() {
  _cached_size_ = 0;
  slice_dim_ = 1u;
  axis_ = 1;
}

SliceParameter::~SliceParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SliceParameter)
  SharedDtor();
}

void SliceParameter::SharedDtor() {
}

void SliceParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SliceParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SliceParameter& SliceParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSliceParameter();
  return *internal_default_instance();
}

SliceParameter* SliceParameter::New(::google::protobuf::Arena* arena) const {
  SliceParameter* n = new SliceParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SliceParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SliceParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  slice_point_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    slice_dim_ = 1u;
    axis_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SliceParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SliceParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 slice_dim = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_slice_dim();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &slice_dim_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 slice_point = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 16u, input, this->mutable_slice_point())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_slice_point())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SliceParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SliceParameter)
  return false;
#undef DO_
}

void SliceParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SliceParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 slice_dim = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->slice_dim(), output);
  }

  // repeated uint32 slice_point = 2;
  for (int i = 0, n = this->slice_point_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
      2, this->slice_point(i), output);
  }

  // optional int32 axis = 3 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->axis(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SliceParameter)
}

::google::protobuf::uint8* SliceParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SliceParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 slice_dim = 1 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->slice_dim(), target);
  }

  // repeated uint32 slice_point = 2;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteUInt32ToArray(2, this->slice_point_, target);

  // optional int32 axis = 3 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->axis(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SliceParameter)
  return target;
}

size_t SliceParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SliceParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated uint32 slice_point = 2;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      UInt32Size(this->slice_point_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->slice_point_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 3u) {
    // optional uint32 slice_dim = 1 [default = 1];
    if (has_slice_dim()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->slice_dim());
    }

    // optional int32 axis = 3 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SliceParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SliceParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const SliceParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SliceParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SliceParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SliceParameter)
    MergeFrom(*source);
  }
}

void SliceParameter::MergeFrom(const SliceParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SliceParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  slice_point_.MergeFrom(from.slice_point_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      slice_dim_ = from.slice_dim_;
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SliceParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SliceParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SliceParameter::CopyFrom(const SliceParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SliceParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SliceParameter::IsInitialized() const {
  return true;
}

void SliceParameter::Swap(SliceParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SliceParameter::InternalSwap(SliceParameter* other) {
  using std::swap;
  slice_point_.InternalSwap(&other->slice_point_);
  swap(slice_dim_, other->slice_dim_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SliceParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SoftmaxParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SoftmaxParameter::kEngineFieldNumber;
const int SoftmaxParameter::kAxisFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SoftmaxParameter::SoftmaxParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSoftmaxParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SoftmaxParameter)
}
SoftmaxParameter::SoftmaxParameter(const SoftmaxParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&engine_, &from.engine_,
    static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
    reinterpret_cast<char*>(&engine_)) + sizeof(axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SoftmaxParameter)
}

void SoftmaxParameter::SharedCtor() {
  _cached_size_ = 0;
  engine_ = 0;
  axis_ = 1;
}

SoftmaxParameter::~SoftmaxParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SoftmaxParameter)
  SharedDtor();
}

void SoftmaxParameter::SharedDtor() {
}

void SoftmaxParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SoftmaxParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SoftmaxParameter& SoftmaxParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSoftmaxParameter();
  return *internal_default_instance();
}

SoftmaxParameter* SoftmaxParameter::New(::google::protobuf::Arena* arena) const {
  SoftmaxParameter* n = new SoftmaxParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SoftmaxParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SoftmaxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    engine_ = 0;
    axis_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SoftmaxParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SoftmaxParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SoftmaxParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::SoftmaxParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 axis = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SoftmaxParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SoftmaxParameter)
  return false;
#undef DO_
}

void SoftmaxParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SoftmaxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->engine(), output);
  }

  // optional int32 axis = 2 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->axis(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SoftmaxParameter)
}

::google::protobuf::uint8* SoftmaxParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SoftmaxParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->engine(), target);
  }

  // optional int32 axis = 2 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->axis(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SoftmaxParameter)
  return target;
}

size_t SoftmaxParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SoftmaxParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional .opencv_caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
    if (has_engine()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
    }

    // optional int32 axis = 2 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SoftmaxParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SoftmaxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const SoftmaxParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SoftmaxParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SoftmaxParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SoftmaxParameter)
    MergeFrom(*source);
  }
}

void SoftmaxParameter::MergeFrom(const SoftmaxParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SoftmaxParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      engine_ = from.engine_;
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SoftmaxParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SoftmaxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SoftmaxParameter::CopyFrom(const SoftmaxParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SoftmaxParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SoftmaxParameter::IsInitialized() const {
  return true;
}

void SoftmaxParameter::Swap(SoftmaxParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SoftmaxParameter::InternalSwap(SoftmaxParameter* other) {
  using std::swap;
  swap(engine_, other->engine_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SoftmaxParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TanHParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TanHParameter::kEngineFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TanHParameter::TanHParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTanHParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.TanHParameter)
}
TanHParameter::TanHParameter(const TanHParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  engine_ = from.engine_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.TanHParameter)
}

void TanHParameter::SharedCtor() {
  _cached_size_ = 0;
  engine_ = 0;
}

TanHParameter::~TanHParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.TanHParameter)
  SharedDtor();
}

void TanHParameter::SharedDtor() {
}

void TanHParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TanHParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TanHParameter& TanHParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTanHParameter();
  return *internal_default_instance();
}

TanHParameter* TanHParameter::New(::google::protobuf::Arena* arena) const {
  TanHParameter* n = new TanHParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TanHParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.TanHParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  engine_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TanHParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.TanHParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::TanHParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::TanHParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.TanHParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.TanHParameter)
  return false;
#undef DO_
}

void TanHParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.TanHParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->engine(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.TanHParameter)
}

::google::protobuf::uint8* TanHParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TanHParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->engine(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TanHParameter)
  return target;
}

size_t TanHParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TanHParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .opencv_caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
  if (has_engine()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TanHParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.TanHParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const TanHParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TanHParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.TanHParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.TanHParameter)
    MergeFrom(*source);
  }
}

void TanHParameter::MergeFrom(const TanHParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TanHParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_engine()) {
    set_engine(from.engine());
  }
}

void TanHParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.TanHParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TanHParameter::CopyFrom(const TanHParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TanHParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TanHParameter::IsInitialized() const {
  return true;
}

void TanHParameter::Swap(TanHParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TanHParameter::InternalSwap(TanHParameter* other) {
  using std::swap;
  swap(engine_, other->engine_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TanHParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TileParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TileParameter::kAxisFieldNumber;
const int TileParameter::kTilesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TileParameter::TileParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTileParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.TileParameter)
}
TileParameter::TileParameter(const TileParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&tiles_, &from.tiles_,
    static_cast<size_t>(reinterpret_cast<char*>(&axis_) -
    reinterpret_cast<char*>(&tiles_)) + sizeof(axis_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.TileParameter)
}

void TileParameter::SharedCtor() {
  _cached_size_ = 0;
  tiles_ = 0;
  axis_ = 1;
}

TileParameter::~TileParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.TileParameter)
  SharedDtor();
}

void TileParameter::SharedDtor() {
}

void TileParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TileParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TileParameter& TileParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsTileParameter();
  return *internal_default_instance();
}

TileParameter* TileParameter::New(::google::protobuf::Arena* arena) const {
  TileParameter* n = new TileParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TileParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.TileParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    tiles_ = 0;
    axis_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TileParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.TileParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 axis = 1 [default = 1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_axis();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &axis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 tiles = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_tiles();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &tiles_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.TileParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.TileParameter)
  return false;
#undef DO_
}

void TileParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.TileParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->axis(), output);
  }

  // optional int32 tiles = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->tiles(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.TileParameter)
}

::google::protobuf::uint8* TileParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.TileParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 axis = 1 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->axis(), target);
  }

  // optional int32 tiles = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->tiles(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.TileParameter)
  return target;
}

size_t TileParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.TileParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 tiles = 2;
    if (has_tiles()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->tiles());
    }

    // optional int32 axis = 1 [default = 1];
    if (has_axis()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->axis());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TileParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.TileParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const TileParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TileParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.TileParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.TileParameter)
    MergeFrom(*source);
  }
}

void TileParameter::MergeFrom(const TileParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.TileParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      tiles_ = from.tiles_;
    }
    if (cached_has_bits & 0x00000002u) {
      axis_ = from.axis_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void TileParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.TileParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TileParameter::CopyFrom(const TileParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.TileParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TileParameter::IsInitialized() const {
  return true;
}

void TileParameter::Swap(TileParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TileParameter::InternalSwap(TileParameter* other) {
  using std::swap;
  swap(tiles_, other->tiles_);
  swap(axis_, other->axis_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TileParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ThresholdParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ThresholdParameter::kThresholdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ThresholdParameter::ThresholdParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsThresholdParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ThresholdParameter)
}
ThresholdParameter::ThresholdParameter(const ThresholdParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  threshold_ = from.threshold_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ThresholdParameter)
}

void ThresholdParameter::SharedCtor() {
  _cached_size_ = 0;
  threshold_ = 0;
}

ThresholdParameter::~ThresholdParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ThresholdParameter)
  SharedDtor();
}

void ThresholdParameter::SharedDtor() {
}

void ThresholdParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ThresholdParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ThresholdParameter& ThresholdParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsThresholdParameter();
  return *internal_default_instance();
}

ThresholdParameter* ThresholdParameter::New(::google::protobuf::Arena* arena) const {
  ThresholdParameter* n = new ThresholdParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ThresholdParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ThresholdParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  threshold_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ThresholdParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ThresholdParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float threshold = 1 [default = 0];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ThresholdParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ThresholdParameter)
  return false;
#undef DO_
}

void ThresholdParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ThresholdParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float threshold = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->threshold(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ThresholdParameter)
}

::google::protobuf::uint8* ThresholdParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ThresholdParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float threshold = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->threshold(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ThresholdParameter)
  return target;
}

size_t ThresholdParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ThresholdParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional float threshold = 1 [default = 0];
  if (has_threshold()) {
    total_size += 1 + 4;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ThresholdParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ThresholdParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ThresholdParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ThresholdParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ThresholdParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ThresholdParameter)
    MergeFrom(*source);
  }
}

void ThresholdParameter::MergeFrom(const ThresholdParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ThresholdParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_threshold()) {
    set_threshold(from.threshold());
  }
}

void ThresholdParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ThresholdParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ThresholdParameter::CopyFrom(const ThresholdParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ThresholdParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ThresholdParameter::IsInitialized() const {
  return true;
}

void ThresholdParameter::Swap(ThresholdParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ThresholdParameter::InternalSwap(ThresholdParameter* other) {
  using std::swap;
  swap(threshold_, other->threshold_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ThresholdParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void WindowDataParameter::InitAsDefaultInstance() {
}
::google::protobuf::internal::ExplicitlyConstructed< ::std::string> WindowDataParameter::_default_crop_mode_;
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int WindowDataParameter::kSourceFieldNumber;
const int WindowDataParameter::kScaleFieldNumber;
const int WindowDataParameter::kMeanFileFieldNumber;
const int WindowDataParameter::kBatchSizeFieldNumber;
const int WindowDataParameter::kCropSizeFieldNumber;
const int WindowDataParameter::kMirrorFieldNumber;
const int WindowDataParameter::kFgThresholdFieldNumber;
const int WindowDataParameter::kBgThresholdFieldNumber;
const int WindowDataParameter::kFgFractionFieldNumber;
const int WindowDataParameter::kContextPadFieldNumber;
const int WindowDataParameter::kCropModeFieldNumber;
const int WindowDataParameter::kCacheImagesFieldNumber;
const int WindowDataParameter::kRootFolderFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

WindowDataParameter::WindowDataParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsWindowDataParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.WindowDataParameter)
}
WindowDataParameter::WindowDataParameter(const WindowDataParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_source()) {
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_mean_file()) {
    mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
  }
  crop_mode_.UnsafeSetDefault(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
  if (from.has_crop_mode()) {
    crop_mode_.AssignWithDefault(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(), from.crop_mode_);
  }
  root_folder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_root_folder()) {
    root_folder_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.root_folder_);
  }
  ::memcpy(&batch_size_, &from.batch_size_,
    static_cast<size_t>(reinterpret_cast<char*>(&fg_fraction_) -
    reinterpret_cast<char*>(&batch_size_)) + sizeof(fg_fraction_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.WindowDataParameter)
}

void WindowDataParameter::SharedCtor() {
  _cached_size_ = 0;
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mean_file_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  crop_mode_.UnsafeSetDefault(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
  root_folder_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&batch_size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&context_pad_) -
      reinterpret_cast<char*>(&batch_size_)) + sizeof(context_pad_));
  scale_ = 1;
  fg_threshold_ = 0.5f;
  bg_threshold_ = 0.5f;
  fg_fraction_ = 0.25f;
}

WindowDataParameter::~WindowDataParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.WindowDataParameter)
  SharedDtor();
}

void WindowDataParameter::SharedDtor() {
  source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  mean_file_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  crop_mode_.DestroyNoArena(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
  root_folder_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void WindowDataParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* WindowDataParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const WindowDataParameter& WindowDataParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsWindowDataParameter();
  return *internal_default_instance();
}

WindowDataParameter* WindowDataParameter::New(::google::protobuf::Arena* arena) const {
  WindowDataParameter* n = new WindowDataParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void WindowDataParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.WindowDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!source_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*source_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!mean_file_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*mean_file_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(!crop_mode_.IsDefault(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get()));
      (*crop_mode_.UnsafeRawStringPointer())->assign(*&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get());
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(!root_folder_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*root_folder_.UnsafeRawStringPointer())->clear();
    }
  }
  if (cached_has_bits & 240u) {
    ::memset(&batch_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&cache_images_) -
        reinterpret_cast<char*>(&batch_size_)) + sizeof(cache_images_));
  }
  if (cached_has_bits & 7936u) {
    context_pad_ = 0u;
    scale_ = 1;
    fg_threshold_ = 0.5f;
    bg_threshold_ = 0.5f;
    fg_fraction_ = 0.25f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool WindowDataParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.WindowDataParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string source = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source().data(), static_cast<int>(this->source().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.WindowDataParameter.source");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string mean_file = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_mean_file()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->mean_file().data(), static_cast<int>(this->mean_file().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.WindowDataParameter.mean_file");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 batch_size = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_batch_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &batch_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 crop_size = 5 [default = 0];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_crop_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &crop_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool mirror = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_mirror();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &mirror_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float fg_threshold = 7 [default = 0.5];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(61u /* 61 & 0xFF */)) {
          set_has_fg_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &fg_threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float bg_threshold = 8 [default = 0.5];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(69u /* 69 & 0xFF */)) {
          set_has_bg_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &bg_threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float fg_fraction = 9 [default = 0.25];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(77u /* 77 & 0xFF */)) {
          set_has_fg_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &fg_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 context_pad = 10 [default = 0];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_context_pad();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &context_pad_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string crop_mode = 11 [default = "warp"];
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_crop_mode()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->crop_mode().data(), static_cast<int>(this->crop_mode().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.WindowDataParameter.crop_mode");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool cache_images = 12 [default = false];
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) {
          set_has_cache_images();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &cache_images_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string root_folder = 13 [default = ""];
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_root_folder()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->root_folder().data(), static_cast<int>(this->root_folder().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.WindowDataParameter.root_folder");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.WindowDataParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.WindowDataParameter)
  return false;
#undef DO_
}

void WindowDataParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.WindowDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.source");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->source(), output);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->scale(), output);
  }

  // optional string mean_file = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.mean_file");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->mean_file(), output);
  }

  // optional uint32 batch_size = 4;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->batch_size(), output);
  }

  // optional uint32 crop_size = 5 [default = 0];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crop_size(), output);
  }

  // optional bool mirror = 6 [default = false];
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->mirror(), output);
  }

  // optional float fg_threshold = 7 [default = 0.5];
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->fg_threshold(), output);
  }

  // optional float bg_threshold = 8 [default = 0.5];
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->bg_threshold(), output);
  }

  // optional float fg_fraction = 9 [default = 0.25];
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->fg_fraction(), output);
  }

  // optional uint32 context_pad = 10 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->context_pad(), output);
  }

  // optional string crop_mode = 11 [default = "warp"];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->crop_mode().data(), static_cast<int>(this->crop_mode().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.crop_mode");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      11, this->crop_mode(), output);
  }

  // optional bool cache_images = 12 [default = false];
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->cache_images(), output);
  }

  // optional string root_folder = 13 [default = ""];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->root_folder().data(), static_cast<int>(this->root_folder().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.root_folder");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      13, this->root_folder(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.WindowDataParameter)
}

::google::protobuf::uint8* WindowDataParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.WindowDataParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string source = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.source");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->source(), target);
  }

  // optional float scale = 2 [default = 1];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->scale(), target);
  }

  // optional string mean_file = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mean_file().data(), static_cast<int>(this->mean_file().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.mean_file");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->mean_file(), target);
  }

  // optional uint32 batch_size = 4;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->batch_size(), target);
  }

  // optional uint32 crop_size = 5 [default = 0];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->crop_size(), target);
  }

  // optional bool mirror = 6 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->mirror(), target);
  }

  // optional float fg_threshold = 7 [default = 0.5];
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->fg_threshold(), target);
  }

  // optional float bg_threshold = 8 [default = 0.5];
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->bg_threshold(), target);
  }

  // optional float fg_fraction = 9 [default = 0.25];
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->fg_fraction(), target);
  }

  // optional uint32 context_pad = 10 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->context_pad(), target);
  }

  // optional string crop_mode = 11 [default = "warp"];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->crop_mode().data(), static_cast<int>(this->crop_mode().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.crop_mode");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        11, this->crop_mode(), target);
  }

  // optional bool cache_images = 12 [default = false];
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->cache_images(), target);
  }

  // optional string root_folder = 13 [default = ""];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->root_folder().data(), static_cast<int>(this->root_folder().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.WindowDataParameter.root_folder");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        13, this->root_folder(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.WindowDataParameter)
  return target;
}

size_t WindowDataParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.WindowDataParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional string source = 1;
    if (has_source()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->source());
    }

    // optional string mean_file = 3;
    if (has_mean_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->mean_file());
    }

    // optional string crop_mode = 11 [default = "warp"];
    if (has_crop_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->crop_mode());
    }

    // optional string root_folder = 13 [default = ""];
    if (has_root_folder()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->root_folder());
    }

    // optional uint32 batch_size = 4;
    if (has_batch_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->batch_size());
    }

    // optional uint32 crop_size = 5 [default = 0];
    if (has_crop_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->crop_size());
    }

    // optional bool mirror = 6 [default = false];
    if (has_mirror()) {
      total_size += 1 + 1;
    }

    // optional bool cache_images = 12 [default = false];
    if (has_cache_images()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & 7936u) {
    // optional uint32 context_pad = 10 [default = 0];
    if (has_context_pad()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->context_pad());
    }

    // optional float scale = 2 [default = 1];
    if (has_scale()) {
      total_size += 1 + 4;
    }

    // optional float fg_threshold = 7 [default = 0.5];
    if (has_fg_threshold()) {
      total_size += 1 + 4;
    }

    // optional float bg_threshold = 8 [default = 0.5];
    if (has_bg_threshold()) {
      total_size += 1 + 4;
    }

    // optional float fg_fraction = 9 [default = 0.25];
    if (has_fg_fraction()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void WindowDataParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.WindowDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const WindowDataParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const WindowDataParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.WindowDataParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.WindowDataParameter)
    MergeFrom(*source);
  }
}

void WindowDataParameter::MergeFrom(const WindowDataParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.WindowDataParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_source();
      source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_mean_file();
      mean_file_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.mean_file_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_crop_mode();
      crop_mode_.AssignWithDefault(&::opencv_caffe::WindowDataParameter::_default_crop_mode_.get(), from.crop_mode_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_root_folder();
      root_folder_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.root_folder_);
    }
    if (cached_has_bits & 0x00000010u) {
      batch_size_ = from.batch_size_;
    }
    if (cached_has_bits & 0x00000020u) {
      crop_size_ = from.crop_size_;
    }
    if (cached_has_bits & 0x00000040u) {
      mirror_ = from.mirror_;
    }
    if (cached_has_bits & 0x00000080u) {
      cache_images_ = from.cache_images_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 7936u) {
    if (cached_has_bits & 0x00000100u) {
      context_pad_ = from.context_pad_;
    }
    if (cached_has_bits & 0x00000200u) {
      scale_ = from.scale_;
    }
    if (cached_has_bits & 0x00000400u) {
      fg_threshold_ = from.fg_threshold_;
    }
    if (cached_has_bits & 0x00000800u) {
      bg_threshold_ = from.bg_threshold_;
    }
    if (cached_has_bits & 0x00001000u) {
      fg_fraction_ = from.fg_fraction_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void WindowDataParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.WindowDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void WindowDataParameter::CopyFrom(const WindowDataParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.WindowDataParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WindowDataParameter::IsInitialized() const {
  return true;
}

void WindowDataParameter::Swap(WindowDataParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void WindowDataParameter::InternalSwap(WindowDataParameter* other) {
  using std::swap;
  source_.Swap(&other->source_);
  mean_file_.Swap(&other->mean_file_);
  crop_mode_.Swap(&other->crop_mode_);
  root_folder_.Swap(&other->root_folder_);
  swap(batch_size_, other->batch_size_);
  swap(crop_size_, other->crop_size_);
  swap(mirror_, other->mirror_);
  swap(cache_images_, other->cache_images_);
  swap(context_pad_, other->context_pad_);
  swap(scale_, other->scale_);
  swap(fg_threshold_, other->fg_threshold_);
  swap(bg_threshold_, other->bg_threshold_);
  swap(fg_fraction_, other->fg_fraction_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata WindowDataParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SPPParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SPPParameter::kPyramidHeightFieldNumber;
const int SPPParameter::kPoolFieldNumber;
const int SPPParameter::kEngineFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SPPParameter::SPPParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSPPParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.SPPParameter)
}
SPPParameter::SPPParameter(const SPPParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&pyramid_height_, &from.pyramid_height_,
    static_cast<size_t>(reinterpret_cast<char*>(&engine_) -
    reinterpret_cast<char*>(&pyramid_height_)) + sizeof(engine_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.SPPParameter)
}

void SPPParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&pyramid_height_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&engine_) -
      reinterpret_cast<char*>(&pyramid_height_)) + sizeof(engine_));
}

SPPParameter::~SPPParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.SPPParameter)
  SharedDtor();
}

void SPPParameter::SharedDtor() {
}

void SPPParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SPPParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SPPParameter& SPPParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsSPPParameter();
  return *internal_default_instance();
}

SPPParameter* SPPParameter::New(::google::protobuf::Arena* arena) const {
  SPPParameter* n = new SPPParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SPPParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.SPPParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ::memset(&pyramid_height_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&engine_) -
        reinterpret_cast<char*>(&pyramid_height_)) + sizeof(engine_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SPPParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.SPPParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 pyramid_height = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_pyramid_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pyramid_height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SPPParameter_PoolMethod_IsValid(value)) {
            set_pool(static_cast< ::opencv_caffe::SPPParameter_PoolMethod >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::SPPParameter_Engine_IsValid(value)) {
            set_engine(static_cast< ::opencv_caffe::SPPParameter_Engine >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                6, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.SPPParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.SPPParameter)
  return false;
#undef DO_
}

void SPPParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.SPPParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 pyramid_height = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->pyramid_height(), output);
  }

  // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->pool(), output);
  }

  // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->engine(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.SPPParameter)
}

::google::protobuf::uint8* SPPParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.SPPParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 pyramid_height = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->pyramid_height(), target);
  }

  // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->pool(), target);
  }

  // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      6, this->engine(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.SPPParameter)
  return target;
}

size_t SPPParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.SPPParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional uint32 pyramid_height = 1;
    if (has_pyramid_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pyramid_height());
    }

    // optional .opencv_caffe.SPPParameter.PoolMethod pool = 2 [default = MAX];
    if (has_pool()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->pool());
    }

    // optional .opencv_caffe.SPPParameter.Engine engine = 6 [default = DEFAULT];
    if (has_engine()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->engine());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SPPParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.SPPParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const SPPParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SPPParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.SPPParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.SPPParameter)
    MergeFrom(*source);
  }
}

void SPPParameter::MergeFrom(const SPPParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.SPPParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      pyramid_height_ = from.pyramid_height_;
    }
    if (cached_has_bits & 0x00000002u) {
      pool_ = from.pool_;
    }
    if (cached_has_bits & 0x00000004u) {
      engine_ = from.engine_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SPPParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.SPPParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SPPParameter::CopyFrom(const SPPParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.SPPParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SPPParameter::IsInitialized() const {
  return true;
}

void SPPParameter::Swap(SPPParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SPPParameter::InternalSwap(SPPParameter* other) {
  using std::swap;
  swap(pyramid_height_, other->pyramid_height_);
  swap(pool_, other->pool_);
  swap(engine_, other->engine_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SPPParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void V1LayerParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->accuracy_param_ = const_cast< ::opencv_caffe::AccuracyParameter*>(
      ::opencv_caffe::AccuracyParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->argmax_param_ = const_cast< ::opencv_caffe::ArgMaxParameter*>(
      ::opencv_caffe::ArgMaxParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->concat_param_ = const_cast< ::opencv_caffe::ConcatParameter*>(
      ::opencv_caffe::ConcatParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->contrastive_loss_param_ = const_cast< ::opencv_caffe::ContrastiveLossParameter*>(
      ::opencv_caffe::ContrastiveLossParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->convolution_param_ = const_cast< ::opencv_caffe::ConvolutionParameter*>(
      ::opencv_caffe::ConvolutionParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->data_param_ = const_cast< ::opencv_caffe::DataParameter*>(
      ::opencv_caffe::DataParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->dropout_param_ = const_cast< ::opencv_caffe::DropoutParameter*>(
      ::opencv_caffe::DropoutParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->dummy_data_param_ = const_cast< ::opencv_caffe::DummyDataParameter*>(
      ::opencv_caffe::DummyDataParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->eltwise_param_ = const_cast< ::opencv_caffe::EltwiseParameter*>(
      ::opencv_caffe::EltwiseParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->exp_param_ = const_cast< ::opencv_caffe::ExpParameter*>(
      ::opencv_caffe::ExpParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->hdf5_data_param_ = const_cast< ::opencv_caffe::HDF5DataParameter*>(
      ::opencv_caffe::HDF5DataParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->hdf5_output_param_ = const_cast< ::opencv_caffe::HDF5OutputParameter*>(
      ::opencv_caffe::HDF5OutputParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->hinge_loss_param_ = const_cast< ::opencv_caffe::HingeLossParameter*>(
      ::opencv_caffe::HingeLossParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->image_data_param_ = const_cast< ::opencv_caffe::ImageDataParameter*>(
      ::opencv_caffe::ImageDataParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->infogain_loss_param_ = const_cast< ::opencv_caffe::InfogainLossParameter*>(
      ::opencv_caffe::InfogainLossParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->inner_product_param_ = const_cast< ::opencv_caffe::InnerProductParameter*>(
      ::opencv_caffe::InnerProductParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->lrn_param_ = const_cast< ::opencv_caffe::LRNParameter*>(
      ::opencv_caffe::LRNParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->memory_data_param_ = const_cast< ::opencv_caffe::MemoryDataParameter*>(
      ::opencv_caffe::MemoryDataParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->mvn_param_ = const_cast< ::opencv_caffe::MVNParameter*>(
      ::opencv_caffe::MVNParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->pooling_param_ = const_cast< ::opencv_caffe::PoolingParameter*>(
      ::opencv_caffe::PoolingParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->power_param_ = const_cast< ::opencv_caffe::PowerParameter*>(
      ::opencv_caffe::PowerParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->relu_param_ = const_cast< ::opencv_caffe::ReLUParameter*>(
      ::opencv_caffe::ReLUParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->sigmoid_param_ = const_cast< ::opencv_caffe::SigmoidParameter*>(
      ::opencv_caffe::SigmoidParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->softmax_param_ = const_cast< ::opencv_caffe::SoftmaxParameter*>(
      ::opencv_caffe::SoftmaxParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->slice_param_ = const_cast< ::opencv_caffe::SliceParameter*>(
      ::opencv_caffe::SliceParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->tanh_param_ = const_cast< ::opencv_caffe::TanHParameter*>(
      ::opencv_caffe::TanHParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->threshold_param_ = const_cast< ::opencv_caffe::ThresholdParameter*>(
      ::opencv_caffe::ThresholdParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->window_data_param_ = const_cast< ::opencv_caffe::WindowDataParameter*>(
      ::opencv_caffe::WindowDataParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->transform_param_ = const_cast< ::opencv_caffe::TransformationParameter*>(
      ::opencv_caffe::TransformationParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->loss_param_ = const_cast< ::opencv_caffe::LossParameter*>(
      ::opencv_caffe::LossParameter::internal_default_instance());
  ::opencv_caffe::_V1LayerParameter_default_instance_._instance.get_mutable()->layer_ = const_cast< ::opencv_caffe::V0LayerParameter*>(
      ::opencv_caffe::V0LayerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int V1LayerParameter::kBottomFieldNumber;
const int V1LayerParameter::kTopFieldNumber;
const int V1LayerParameter::kNameFieldNumber;
const int V1LayerParameter::kIncludeFieldNumber;
const int V1LayerParameter::kExcludeFieldNumber;
const int V1LayerParameter::kTypeFieldNumber;
const int V1LayerParameter::kBlobsFieldNumber;
const int V1LayerParameter::kParamFieldNumber;
const int V1LayerParameter::kBlobShareModeFieldNumber;
const int V1LayerParameter::kBlobsLrFieldNumber;
const int V1LayerParameter::kWeightDecayFieldNumber;
const int V1LayerParameter::kLossWeightFieldNumber;
const int V1LayerParameter::kAccuracyParamFieldNumber;
const int V1LayerParameter::kArgmaxParamFieldNumber;
const int V1LayerParameter::kConcatParamFieldNumber;
const int V1LayerParameter::kContrastiveLossParamFieldNumber;
const int V1LayerParameter::kConvolutionParamFieldNumber;
const int V1LayerParameter::kDataParamFieldNumber;
const int V1LayerParameter::kDropoutParamFieldNumber;
const int V1LayerParameter::kDummyDataParamFieldNumber;
const int V1LayerParameter::kEltwiseParamFieldNumber;
const int V1LayerParameter::kExpParamFieldNumber;
const int V1LayerParameter::kHdf5DataParamFieldNumber;
const int V1LayerParameter::kHdf5OutputParamFieldNumber;
const int V1LayerParameter::kHingeLossParamFieldNumber;
const int V1LayerParameter::kImageDataParamFieldNumber;
const int V1LayerParameter::kInfogainLossParamFieldNumber;
const int V1LayerParameter::kInnerProductParamFieldNumber;
const int V1LayerParameter::kLrnParamFieldNumber;
const int V1LayerParameter::kMemoryDataParamFieldNumber;
const int V1LayerParameter::kMvnParamFieldNumber;
const int V1LayerParameter::kPoolingParamFieldNumber;
const int V1LayerParameter::kPowerParamFieldNumber;
const int V1LayerParameter::kReluParamFieldNumber;
const int V1LayerParameter::kSigmoidParamFieldNumber;
const int V1LayerParameter::kSoftmaxParamFieldNumber;
const int V1LayerParameter::kSliceParamFieldNumber;
const int V1LayerParameter::kTanhParamFieldNumber;
const int V1LayerParameter::kThresholdParamFieldNumber;
const int V1LayerParameter::kWindowDataParamFieldNumber;
const int V1LayerParameter::kTransformParamFieldNumber;
const int V1LayerParameter::kLossParamFieldNumber;
const int V1LayerParameter::kLayerFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

V1LayerParameter::V1LayerParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsV1LayerParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.V1LayerParameter)
}
V1LayerParameter::V1LayerParameter(const V1LayerParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      bottom_(from.bottom_),
      top_(from.top_),
      blobs_(from.blobs_),
      blobs_lr_(from.blobs_lr_),
      weight_decay_(from.weight_decay_),
      include_(from.include_),
      exclude_(from.exclude_),
      loss_weight_(from.loss_weight_),
      param_(from.param_),
      blob_share_mode_(from.blob_share_mode_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.has_layer()) {
    layer_ = new ::opencv_caffe::V0LayerParameter(*from.layer_);
  } else {
    layer_ = NULL;
  }
  if (from.has_concat_param()) {
    concat_param_ = new ::opencv_caffe::ConcatParameter(*from.concat_param_);
  } else {
    concat_param_ = NULL;
  }
  if (from.has_convolution_param()) {
    convolution_param_ = new ::opencv_caffe::ConvolutionParameter(*from.convolution_param_);
  } else {
    convolution_param_ = NULL;
  }
  if (from.has_data_param()) {
    data_param_ = new ::opencv_caffe::DataParameter(*from.data_param_);
  } else {
    data_param_ = NULL;
  }
  if (from.has_dropout_param()) {
    dropout_param_ = new ::opencv_caffe::DropoutParameter(*from.dropout_param_);
  } else {
    dropout_param_ = NULL;
  }
  if (from.has_hdf5_data_param()) {
    hdf5_data_param_ = new ::opencv_caffe::HDF5DataParameter(*from.hdf5_data_param_);
  } else {
    hdf5_data_param_ = NULL;
  }
  if (from.has_hdf5_output_param()) {
    hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_);
  } else {
    hdf5_output_param_ = NULL;
  }
  if (from.has_image_data_param()) {
    image_data_param_ = new ::opencv_caffe::ImageDataParameter(*from.image_data_param_);
  } else {
    image_data_param_ = NULL;
  }
  if (from.has_infogain_loss_param()) {
    infogain_loss_param_ = new ::opencv_caffe::InfogainLossParameter(*from.infogain_loss_param_);
  } else {
    infogain_loss_param_ = NULL;
  }
  if (from.has_inner_product_param()) {
    inner_product_param_ = new ::opencv_caffe::InnerProductParameter(*from.inner_product_param_);
  } else {
    inner_product_param_ = NULL;
  }
  if (from.has_lrn_param()) {
    lrn_param_ = new ::opencv_caffe::LRNParameter(*from.lrn_param_);
  } else {
    lrn_param_ = NULL;
  }
  if (from.has_pooling_param()) {
    pooling_param_ = new ::opencv_caffe::PoolingParameter(*from.pooling_param_);
  } else {
    pooling_param_ = NULL;
  }
  if (from.has_window_data_param()) {
    window_data_param_ = new ::opencv_caffe::WindowDataParameter(*from.window_data_param_);
  } else {
    window_data_param_ = NULL;
  }
  if (from.has_power_param()) {
    power_param_ = new ::opencv_caffe::PowerParameter(*from.power_param_);
  } else {
    power_param_ = NULL;
  }
  if (from.has_memory_data_param()) {
    memory_data_param_ = new ::opencv_caffe::MemoryDataParameter(*from.memory_data_param_);
  } else {
    memory_data_param_ = NULL;
  }
  if (from.has_argmax_param()) {
    argmax_param_ = new ::opencv_caffe::ArgMaxParameter(*from.argmax_param_);
  } else {
    argmax_param_ = NULL;
  }
  if (from.has_eltwise_param()) {
    eltwise_param_ = new ::opencv_caffe::EltwiseParameter(*from.eltwise_param_);
  } else {
    eltwise_param_ = NULL;
  }
  if (from.has_threshold_param()) {
    threshold_param_ = new ::opencv_caffe::ThresholdParameter(*from.threshold_param_);
  } else {
    threshold_param_ = NULL;
  }
  if (from.has_dummy_data_param()) {
    dummy_data_param_ = new ::opencv_caffe::DummyDataParameter(*from.dummy_data_param_);
  } else {
    dummy_data_param_ = NULL;
  }
  if (from.has_accuracy_param()) {
    accuracy_param_ = new ::opencv_caffe::AccuracyParameter(*from.accuracy_param_);
  } else {
    accuracy_param_ = NULL;
  }
  if (from.has_hinge_loss_param()) {
    hinge_loss_param_ = new ::opencv_caffe::HingeLossParameter(*from.hinge_loss_param_);
  } else {
    hinge_loss_param_ = NULL;
  }
  if (from.has_relu_param()) {
    relu_param_ = new ::opencv_caffe::ReLUParameter(*from.relu_param_);
  } else {
    relu_param_ = NULL;
  }
  if (from.has_slice_param()) {
    slice_param_ = new ::opencv_caffe::SliceParameter(*from.slice_param_);
  } else {
    slice_param_ = NULL;
  }
  if (from.has_mvn_param()) {
    mvn_param_ = new ::opencv_caffe::MVNParameter(*from.mvn_param_);
  } else {
    mvn_param_ = NULL;
  }
  if (from.has_transform_param()) {
    transform_param_ = new ::opencv_caffe::TransformationParameter(*from.transform_param_);
  } else {
    transform_param_ = NULL;
  }
  if (from.has_tanh_param()) {
    tanh_param_ = new ::opencv_caffe::TanHParameter(*from.tanh_param_);
  } else {
    tanh_param_ = NULL;
  }
  if (from.has_sigmoid_param()) {
    sigmoid_param_ = new ::opencv_caffe::SigmoidParameter(*from.sigmoid_param_);
  } else {
    sigmoid_param_ = NULL;
  }
  if (from.has_softmax_param()) {
    softmax_param_ = new ::opencv_caffe::SoftmaxParameter(*from.softmax_param_);
  } else {
    softmax_param_ = NULL;
  }
  if (from.has_contrastive_loss_param()) {
    contrastive_loss_param_ = new ::opencv_caffe::ContrastiveLossParameter(*from.contrastive_loss_param_);
  } else {
    contrastive_loss_param_ = NULL;
  }
  if (from.has_exp_param()) {
    exp_param_ = new ::opencv_caffe::ExpParameter(*from.exp_param_);
  } else {
    exp_param_ = NULL;
  }
  if (from.has_loss_param()) {
    loss_param_ = new ::opencv_caffe::LossParameter(*from.loss_param_);
  } else {
    loss_param_ = NULL;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.V1LayerParameter)
}

void V1LayerParameter::SharedCtor() {
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&layer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&layer_)) + sizeof(type_));
  _cached_size_ = 0;
}

V1LayerParameter::~V1LayerParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.V1LayerParameter)
  SharedDtor();
}

void V1LayerParameter::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete layer_;
  if (this != internal_default_instance()) delete concat_param_;
  if (this != internal_default_instance()) delete convolution_param_;
  if (this != internal_default_instance()) delete data_param_;
  if (this != internal_default_instance()) delete dropout_param_;
  if (this != internal_default_instance()) delete hdf5_data_param_;
  if (this != internal_default_instance()) delete hdf5_output_param_;
  if (this != internal_default_instance()) delete image_data_param_;
  if (this != internal_default_instance()) delete infogain_loss_param_;
  if (this != internal_default_instance()) delete inner_product_param_;
  if (this != internal_default_instance()) delete lrn_param_;
  if (this != internal_default_instance()) delete pooling_param_;
  if (this != internal_default_instance()) delete window_data_param_;
  if (this != internal_default_instance()) delete power_param_;
  if (this != internal_default_instance()) delete memory_data_param_;
  if (this != internal_default_instance()) delete argmax_param_;
  if (this != internal_default_instance()) delete eltwise_param_;
  if (this != internal_default_instance()) delete threshold_param_;
  if (this != internal_default_instance()) delete dummy_data_param_;
  if (this != internal_default_instance()) delete accuracy_param_;
  if (this != internal_default_instance()) delete hinge_loss_param_;
  if (this != internal_default_instance()) delete relu_param_;
  if (this != internal_default_instance()) delete slice_param_;
  if (this != internal_default_instance()) delete mvn_param_;
  if (this != internal_default_instance()) delete transform_param_;
  if (this != internal_default_instance()) delete tanh_param_;
  if (this != internal_default_instance()) delete sigmoid_param_;
  if (this != internal_default_instance()) delete softmax_param_;
  if (this != internal_default_instance()) delete contrastive_loss_param_;
  if (this != internal_default_instance()) delete exp_param_;
  if (this != internal_default_instance()) delete loss_param_;
}

void V1LayerParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* V1LayerParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const V1LayerParameter& V1LayerParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsV1LayerParameter();
  return *internal_default_instance();
}

V1LayerParameter* V1LayerParameter::New(::google::protobuf::Arena* arena) const {
  V1LayerParameter* n = new V1LayerParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void V1LayerParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.V1LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  bottom_.Clear();
  top_.Clear();
  blobs_.Clear();
  blobs_lr_.Clear();
  weight_decay_.Clear();
  include_.Clear();
  exclude_.Clear();
  loss_weight_.Clear();
  param_.Clear();
  blob_share_mode_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*name_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(layer_ != NULL);
      layer_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(concat_param_ != NULL);
      concat_param_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(convolution_param_ != NULL);
      convolution_param_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(data_param_ != NULL);
      data_param_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(dropout_param_ != NULL);
      dropout_param_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(hdf5_data_param_ != NULL);
      hdf5_data_param_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(hdf5_output_param_ != NULL);
      hdf5_output_param_->Clear();
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(image_data_param_ != NULL);
      image_data_param_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(infogain_loss_param_ != NULL);
      infogain_loss_param_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(inner_product_param_ != NULL);
      inner_product_param_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(lrn_param_ != NULL);
      lrn_param_->Clear();
    }
    if (cached_has_bits & 0x00001000u) {
      GOOGLE_DCHECK(pooling_param_ != NULL);
      pooling_param_->Clear();
    }
    if (cached_has_bits & 0x00002000u) {
      GOOGLE_DCHECK(window_data_param_ != NULL);
      window_data_param_->Clear();
    }
    if (cached_has_bits & 0x00004000u) {
      GOOGLE_DCHECK(power_param_ != NULL);
      power_param_->Clear();
    }
    if (cached_has_bits & 0x00008000u) {
      GOOGLE_DCHECK(memory_data_param_ != NULL);
      memory_data_param_->Clear();
    }
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      GOOGLE_DCHECK(argmax_param_ != NULL);
      argmax_param_->Clear();
    }
    if (cached_has_bits & 0x00020000u) {
      GOOGLE_DCHECK(eltwise_param_ != NULL);
      eltwise_param_->Clear();
    }
    if (cached_has_bits & 0x00040000u) {
      GOOGLE_DCHECK(threshold_param_ != NULL);
      threshold_param_->Clear();
    }
    if (cached_has_bits & 0x00080000u) {
      GOOGLE_DCHECK(dummy_data_param_ != NULL);
      dummy_data_param_->Clear();
    }
    if (cached_has_bits & 0x00100000u) {
      GOOGLE_DCHECK(accuracy_param_ != NULL);
      accuracy_param_->Clear();
    }
    if (cached_has_bits & 0x00200000u) {
      GOOGLE_DCHECK(hinge_loss_param_ != NULL);
      hinge_loss_param_->Clear();
    }
    if (cached_has_bits & 0x00400000u) {
      GOOGLE_DCHECK(relu_param_ != NULL);
      relu_param_->Clear();
    }
    if (cached_has_bits & 0x00800000u) {
      GOOGLE_DCHECK(slice_param_ != NULL);
      slice_param_->Clear();
    }
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      GOOGLE_DCHECK(mvn_param_ != NULL);
      mvn_param_->Clear();
    }
    if (cached_has_bits & 0x02000000u) {
      GOOGLE_DCHECK(transform_param_ != NULL);
      transform_param_->Clear();
    }
    if (cached_has_bits & 0x04000000u) {
      GOOGLE_DCHECK(tanh_param_ != NULL);
      tanh_param_->Clear();
    }
    if (cached_has_bits & 0x08000000u) {
      GOOGLE_DCHECK(sigmoid_param_ != NULL);
      sigmoid_param_->Clear();
    }
    if (cached_has_bits & 0x10000000u) {
      GOOGLE_DCHECK(softmax_param_ != NULL);
      softmax_param_->Clear();
    }
    if (cached_has_bits & 0x20000000u) {
      GOOGLE_DCHECK(contrastive_loss_param_ != NULL);
      contrastive_loss_param_->Clear();
    }
    if (cached_has_bits & 0x40000000u) {
      GOOGLE_DCHECK(exp_param_ != NULL);
      exp_param_->Clear();
    }
    if (cached_has_bits & 0x80000000u) {
      GOOGLE_DCHECK(loss_param_ != NULL);
      loss_param_->Clear();
    }
  }
  type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool V1LayerParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.V1LayerParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.V0LayerParameter layer = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_layer()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string bottom = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_bottom()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->bottom(this->bottom_size() - 1).data(),
            static_cast<int>(this->bottom(this->bottom_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V1LayerParameter.bottom");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string top = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_top()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->top(this->top_size() - 1).data(),
            static_cast<int>(this->top(this->top_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V1LayerParameter.top");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string name = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V1LayerParameter.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::V1LayerParameter_LayerType_IsValid(value)) {
            set_type(static_cast< ::opencv_caffe::V1LayerParameter_LayerType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                5, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.BlobProto blobs = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_blobs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float blobs_lr = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(61u /* 61 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 61u, input, this->mutable_blobs_lr())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_blobs_lr())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float weight_decay = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(69u /* 69 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 69u, input, this->mutable_weight_decay())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_weight_decay())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ConcatParameter concat_param = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_concat_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_convolution_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DataParameter data_param = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DropoutParameter dropout_param = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_dropout_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hdf5_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(114u /* 114 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hdf5_output_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ImageDataParameter image_data_param = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(122u /* 122 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_image_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(130u /* 130 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_infogain_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(138u /* 138 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_inner_product_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LRNParameter lrn_param = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 146 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_lrn_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PoolingParameter pooling_param = 19;
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(154u /* 154 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_pooling_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.WindowDataParameter window_data_param = 20;
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(162u /* 162 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_window_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.PowerParameter power_param = 21;
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u /* 170 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_power_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u /* 178 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_memory_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
      case 23: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(186u /* 186 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_argmax_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
      case 24: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u /* 194 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_eltwise_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ThresholdParameter threshold_param = 25;
      case 25: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(202u /* 202 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_threshold_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
      case 26: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(210u /* 210 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_dummy_data_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
      case 27: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(218u /* 218 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_accuracy_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
      case 29: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(234u /* 234 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hinge_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ReLUParameter relu_param = 30;
      case 30: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(242u /* 242 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_relu_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SliceParameter slice_param = 31;
      case 31: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(250u /* 250 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_slice_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.NetStateRule include = 32;
      case 32: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(2u /* 258 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_include()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.NetStateRule exclude = 33;
      case 33: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 266 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_exclude()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.MVNParameter mvn_param = 34;
      case 34: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 274 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_mvn_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float loss_weight = 35;
      case 35: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 285 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 2, 285u, input, this->mutable_loss_weight())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 282 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_loss_weight())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.TransformationParameter transform_param = 36;
      case 36: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 290 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_transform_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.TanHParameter tanh_param = 37;
      case 37: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 298 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_tanh_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
      case 38: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 306 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_sigmoid_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
      case 39: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 314 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_softmax_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
      case 40: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 322 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_contrastive_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.ExpParameter exp_param = 41;
      case 41: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 330 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_exp_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.LossParameter loss_param = 42;
      case 42: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 338 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_loss_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string param = 1001;
      case 1001: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 8010 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_param()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->param(this->param_size() - 1).data(),
            static_cast<int>(this->param(this->param_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V1LayerParameter.param");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
      case 1002: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 8016 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid(value)) {
            add_blob_share_mode(static_cast< ::opencv_caffe::V1LayerParameter_DimCheckMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1002, static_cast< ::google::protobuf::uint64>(value));
          }
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 8018 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(
                 input,
                 1002,
                 ::opencv_caffe::V1LayerParameter_DimCheckMode_IsValid,
                 mutable_unknown_fields(),
                 this->mutable_blob_share_mode())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.V1LayerParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.V1LayerParameter)
  return false;
#undef DO_
}

void V1LayerParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.V1LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.V0LayerParameter layer = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->layer_, output);
  }

  // repeated string bottom = 2;
  for (int i = 0, n = this->bottom_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->bottom(i).data(), static_cast<int>(this->bottom(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.bottom");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->bottom(i), output);
  }

  // repeated string top = 3;
  for (int i = 0, n = this->top_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->top(i).data(), static_cast<int>(this->top(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.top");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->top(i), output);
  }

  // optional string name = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->name(), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->type(), output);
  }

  // repeated .opencv_caffe.BlobProto blobs = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->blobs(static_cast<int>(i)), output);
  }

  // repeated float blobs_lr = 7;
  for (int i = 0, n = this->blobs_lr_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      7, this->blobs_lr(i), output);
  }

  // repeated float weight_decay = 8;
  for (int i = 0, n = this->weight_decay_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      8, this->weight_decay(i), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.ConcatParameter concat_param = 9;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, *this->concat_param_, output);
  }

  // optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      10, *this->convolution_param_, output);
  }

  // optional .opencv_caffe.DataParameter data_param = 11;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      11, *this->data_param_, output);
  }

  // optional .opencv_caffe.DropoutParameter dropout_param = 12;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      12, *this->dropout_param_, output);
  }

  // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      13, *this->hdf5_data_param_, output);
  }

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      14, *this->hdf5_output_param_, output);
  }

  // optional .opencv_caffe.ImageDataParameter image_data_param = 15;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      15, *this->image_data_param_, output);
  }

  // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      16, *this->infogain_loss_param_, output);
  }

  // optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      17, *this->inner_product_param_, output);
  }

  // optional .opencv_caffe.LRNParameter lrn_param = 18;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      18, *this->lrn_param_, output);
  }

  // optional .opencv_caffe.PoolingParameter pooling_param = 19;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      19, *this->pooling_param_, output);
  }

  // optional .opencv_caffe.WindowDataParameter window_data_param = 20;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      20, *this->window_data_param_, output);
  }

  // optional .opencv_caffe.PowerParameter power_param = 21;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      21, *this->power_param_, output);
  }

  // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      22, *this->memory_data_param_, output);
  }

  // optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      23, *this->argmax_param_, output);
  }

  // optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      24, *this->eltwise_param_, output);
  }

  // optional .opencv_caffe.ThresholdParameter threshold_param = 25;
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      25, *this->threshold_param_, output);
  }

  // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
  if (cached_has_bits & 0x00080000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      26, *this->dummy_data_param_, output);
  }

  // optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
  if (cached_has_bits & 0x00100000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      27, *this->accuracy_param_, output);
  }

  // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
  if (cached_has_bits & 0x00200000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      29, *this->hinge_loss_param_, output);
  }

  // optional .opencv_caffe.ReLUParameter relu_param = 30;
  if (cached_has_bits & 0x00400000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      30, *this->relu_param_, output);
  }

  // optional .opencv_caffe.SliceParameter slice_param = 31;
  if (cached_has_bits & 0x00800000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      31, *this->slice_param_, output);
  }

  // repeated .opencv_caffe.NetStateRule include = 32;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->include_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      32, this->include(static_cast<int>(i)), output);
  }

  // repeated .opencv_caffe.NetStateRule exclude = 33;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->exclude_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      33, this->exclude(static_cast<int>(i)), output);
  }

  // optional .opencv_caffe.MVNParameter mvn_param = 34;
  if (cached_has_bits & 0x01000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      34, *this->mvn_param_, output);
  }

  // repeated float loss_weight = 35;
  for (int i = 0, n = this->loss_weight_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      35, this->loss_weight(i), output);
  }

  // optional .opencv_caffe.TransformationParameter transform_param = 36;
  if (cached_has_bits & 0x02000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      36, *this->transform_param_, output);
  }

  // optional .opencv_caffe.TanHParameter tanh_param = 37;
  if (cached_has_bits & 0x04000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      37, *this->tanh_param_, output);
  }

  // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
  if (cached_has_bits & 0x08000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      38, *this->sigmoid_param_, output);
  }

  // optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
  if (cached_has_bits & 0x10000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      39, *this->softmax_param_, output);
  }

  // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
  if (cached_has_bits & 0x20000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      40, *this->contrastive_loss_param_, output);
  }

  // optional .opencv_caffe.ExpParameter exp_param = 41;
  if (cached_has_bits & 0x40000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      41, *this->exp_param_, output);
  }

  // optional .opencv_caffe.LossParameter loss_param = 42;
  if (cached_has_bits & 0x80000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      42, *this->loss_param_, output);
  }

  // repeated string param = 1001;
  for (int i = 0, n = this->param_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->param(i).data(), static_cast<int>(this->param(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.param");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1001, this->param(i), output);
  }

  // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
  for (int i = 0, n = this->blob_share_mode_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1002, this->blob_share_mode(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.V1LayerParameter)
}

::google::protobuf::uint8* V1LayerParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.V1LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.V0LayerParameter layer = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->layer_, deterministic, target);
  }

  // repeated string bottom = 2;
  for (int i = 0, n = this->bottom_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->bottom(i).data(), static_cast<int>(this->bottom(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.bottom");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(2, this->bottom(i), target);
  }

  // repeated string top = 3;
  for (int i = 0, n = this->top_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->top(i).data(), static_cast<int>(this->top(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.top");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(3, this->top(i), target);
  }

  // optional string name = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->name(), target);
  }

  cached_has_bits = _has_bits_[1];
  // optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      5, this->type(), target);
  }

  // repeated .opencv_caffe.BlobProto blobs = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, this->blobs(static_cast<int>(i)), deterministic, target);
  }

  // repeated float blobs_lr = 7;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(7, this->blobs_lr_, target);

  // repeated float weight_decay = 8;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(8, this->weight_decay_, target);

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.ConcatParameter concat_param = 9;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        9, *this->concat_param_, deterministic, target);
  }

  // optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        10, *this->convolution_param_, deterministic, target);
  }

  // optional .opencv_caffe.DataParameter data_param = 11;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        11, *this->data_param_, deterministic, target);
  }

  // optional .opencv_caffe.DropoutParameter dropout_param = 12;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        12, *this->dropout_param_, deterministic, target);
  }

  // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        13, *this->hdf5_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        14, *this->hdf5_output_param_, deterministic, target);
  }

  // optional .opencv_caffe.ImageDataParameter image_data_param = 15;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        15, *this->image_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        16, *this->infogain_loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        17, *this->inner_product_param_, deterministic, target);
  }

  // optional .opencv_caffe.LRNParameter lrn_param = 18;
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        18, *this->lrn_param_, deterministic, target);
  }

  // optional .opencv_caffe.PoolingParameter pooling_param = 19;
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        19, *this->pooling_param_, deterministic, target);
  }

  // optional .opencv_caffe.WindowDataParameter window_data_param = 20;
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        20, *this->window_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.PowerParameter power_param = 21;
  if (cached_has_bits & 0x00004000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        21, *this->power_param_, deterministic, target);
  }

  // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
  if (cached_has_bits & 0x00008000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        22, *this->memory_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
  if (cached_has_bits & 0x00010000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        23, *this->argmax_param_, deterministic, target);
  }

  // optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
  if (cached_has_bits & 0x00020000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        24, *this->eltwise_param_, deterministic, target);
  }

  // optional .opencv_caffe.ThresholdParameter threshold_param = 25;
  if (cached_has_bits & 0x00040000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        25, *this->threshold_param_, deterministic, target);
  }

  // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
  if (cached_has_bits & 0x00080000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        26, *this->dummy_data_param_, deterministic, target);
  }

  // optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
  if (cached_has_bits & 0x00100000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        27, *this->accuracy_param_, deterministic, target);
  }

  // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
  if (cached_has_bits & 0x00200000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        29, *this->hinge_loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.ReLUParameter relu_param = 30;
  if (cached_has_bits & 0x00400000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        30, *this->relu_param_, deterministic, target);
  }

  // optional .opencv_caffe.SliceParameter slice_param = 31;
  if (cached_has_bits & 0x00800000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        31, *this->slice_param_, deterministic, target);
  }

  // repeated .opencv_caffe.NetStateRule include = 32;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->include_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        32, this->include(static_cast<int>(i)), deterministic, target);
  }

  // repeated .opencv_caffe.NetStateRule exclude = 33;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->exclude_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        33, this->exclude(static_cast<int>(i)), deterministic, target);
  }

  // optional .opencv_caffe.MVNParameter mvn_param = 34;
  if (cached_has_bits & 0x01000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        34, *this->mvn_param_, deterministic, target);
  }

  // repeated float loss_weight = 35;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(35, this->loss_weight_, target);

  // optional .opencv_caffe.TransformationParameter transform_param = 36;
  if (cached_has_bits & 0x02000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        36, *this->transform_param_, deterministic, target);
  }

  // optional .opencv_caffe.TanHParameter tanh_param = 37;
  if (cached_has_bits & 0x04000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        37, *this->tanh_param_, deterministic, target);
  }

  // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
  if (cached_has_bits & 0x08000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        38, *this->sigmoid_param_, deterministic, target);
  }

  // optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
  if (cached_has_bits & 0x10000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        39, *this->softmax_param_, deterministic, target);
  }

  // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
  if (cached_has_bits & 0x20000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        40, *this->contrastive_loss_param_, deterministic, target);
  }

  // optional .opencv_caffe.ExpParameter exp_param = 41;
  if (cached_has_bits & 0x40000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        41, *this->exp_param_, deterministic, target);
  }

  // optional .opencv_caffe.LossParameter loss_param = 42;
  if (cached_has_bits & 0x80000000u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        42, *this->loss_param_, deterministic, target);
  }

  // repeated string param = 1001;
  for (int i = 0, n = this->param_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->param(i).data(), static_cast<int>(this->param(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V1LayerParameter.param");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(1001, this->param(i), target);
  }

  // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
  target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
    1002, this->blob_share_mode_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.V1LayerParameter)
  return target;
}

size_t V1LayerParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.V1LayerParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string bottom = 2;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->bottom_size());
  for (int i = 0, n = this->bottom_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->bottom(i));
  }

  // repeated string top = 3;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->top_size());
  for (int i = 0, n = this->top_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->top(i));
  }

  // repeated .opencv_caffe.BlobProto blobs = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->blobs_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->blobs(static_cast<int>(i)));
    }
  }

  // repeated float blobs_lr = 7;
  {
    unsigned int count = static_cast<unsigned int>(this->blobs_lr_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->blobs_lr_size());
    total_size += data_size;
  }

  // repeated float weight_decay = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->weight_decay_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->weight_decay_size());
    total_size += data_size;
  }

  // repeated .opencv_caffe.NetStateRule include = 32;
  {
    unsigned int count = static_cast<unsigned int>(this->include_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->include(static_cast<int>(i)));
    }
  }

  // repeated .opencv_caffe.NetStateRule exclude = 33;
  {
    unsigned int count = static_cast<unsigned int>(this->exclude_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->exclude(static_cast<int>(i)));
    }
  }

  // repeated float loss_weight = 35;
  {
    unsigned int count = static_cast<unsigned int>(this->loss_weight_size());
    size_t data_size = 4UL * count;
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->loss_weight_size());
    total_size += data_size;
  }

  // repeated string param = 1001;
  total_size += 2 *
      ::google::protobuf::internal::FromIntSize(this->param_size());
  for (int i = 0, n = this->param_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->param(i));
  }

  // repeated .opencv_caffe.V1LayerParameter.DimCheckMode blob_share_mode = 1002;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->blob_share_mode_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->blob_share_mode(static_cast<int>(i)));
    }
    total_size += (2UL * count) + data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional string name = 4;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional .opencv_caffe.V0LayerParameter layer = 1;
    if (has_layer()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->layer_);
    }

    // optional .opencv_caffe.ConcatParameter concat_param = 9;
    if (has_concat_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->concat_param_);
    }

    // optional .opencv_caffe.ConvolutionParameter convolution_param = 10;
    if (has_convolution_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->convolution_param_);
    }

    // optional .opencv_caffe.DataParameter data_param = 11;
    if (has_data_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->data_param_);
    }

    // optional .opencv_caffe.DropoutParameter dropout_param = 12;
    if (has_dropout_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->dropout_param_);
    }

    // optional .opencv_caffe.HDF5DataParameter hdf5_data_param = 13;
    if (has_hdf5_data_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hdf5_data_param_);
    }

    // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 14;
    if (has_hdf5_output_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hdf5_output_param_);
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional .opencv_caffe.ImageDataParameter image_data_param = 15;
    if (has_image_data_param()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->image_data_param_);
    }

    // optional .opencv_caffe.InfogainLossParameter infogain_loss_param = 16;
    if (has_infogain_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->infogain_loss_param_);
    }

    // optional .opencv_caffe.InnerProductParameter inner_product_param = 17;
    if (has_inner_product_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->inner_product_param_);
    }

    // optional .opencv_caffe.LRNParameter lrn_param = 18;
    if (has_lrn_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->lrn_param_);
    }

    // optional .opencv_caffe.PoolingParameter pooling_param = 19;
    if (has_pooling_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->pooling_param_);
    }

    // optional .opencv_caffe.WindowDataParameter window_data_param = 20;
    if (has_window_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->window_data_param_);
    }

    // optional .opencv_caffe.PowerParameter power_param = 21;
    if (has_power_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->power_param_);
    }

    // optional .opencv_caffe.MemoryDataParameter memory_data_param = 22;
    if (has_memory_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->memory_data_param_);
    }

  }
  if (_has_bits_[16 / 32] & 16711680u) {
    // optional .opencv_caffe.ArgMaxParameter argmax_param = 23;
    if (has_argmax_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->argmax_param_);
    }

    // optional .opencv_caffe.EltwiseParameter eltwise_param = 24;
    if (has_eltwise_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->eltwise_param_);
    }

    // optional .opencv_caffe.ThresholdParameter threshold_param = 25;
    if (has_threshold_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->threshold_param_);
    }

    // optional .opencv_caffe.DummyDataParameter dummy_data_param = 26;
    if (has_dummy_data_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->dummy_data_param_);
    }

    // optional .opencv_caffe.AccuracyParameter accuracy_param = 27;
    if (has_accuracy_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->accuracy_param_);
    }

    // optional .opencv_caffe.HingeLossParameter hinge_loss_param = 29;
    if (has_hinge_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hinge_loss_param_);
    }

    // optional .opencv_caffe.ReLUParameter relu_param = 30;
    if (has_relu_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->relu_param_);
    }

    // optional .opencv_caffe.SliceParameter slice_param = 31;
    if (has_slice_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->slice_param_);
    }

  }
  if (_has_bits_[24 / 32] & 4278190080u) {
    // optional .opencv_caffe.MVNParameter mvn_param = 34;
    if (has_mvn_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->mvn_param_);
    }

    // optional .opencv_caffe.TransformationParameter transform_param = 36;
    if (has_transform_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->transform_param_);
    }

    // optional .opencv_caffe.TanHParameter tanh_param = 37;
    if (has_tanh_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->tanh_param_);
    }

    // optional .opencv_caffe.SigmoidParameter sigmoid_param = 38;
    if (has_sigmoid_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->sigmoid_param_);
    }

    // optional .opencv_caffe.SoftmaxParameter softmax_param = 39;
    if (has_softmax_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->softmax_param_);
    }

    // optional .opencv_caffe.ContrastiveLossParameter contrastive_loss_param = 40;
    if (has_contrastive_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->contrastive_loss_param_);
    }

    // optional .opencv_caffe.ExpParameter exp_param = 41;
    if (has_exp_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->exp_param_);
    }

    // optional .opencv_caffe.LossParameter loss_param = 42;
    if (has_loss_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->loss_param_);
    }

  }
  // optional .opencv_caffe.V1LayerParameter.LayerType type = 5;
  if (has_type()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void V1LayerParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.V1LayerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const V1LayerParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const V1LayerParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.V1LayerParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.V1LayerParameter)
    MergeFrom(*source);
  }
}

void V1LayerParameter::MergeFrom(const V1LayerParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.V1LayerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  bottom_.MergeFrom(from.bottom_);
  top_.MergeFrom(from.top_);
  blobs_.MergeFrom(from.blobs_);
  blobs_lr_.MergeFrom(from.blobs_lr_);
  weight_decay_.MergeFrom(from.weight_decay_);
  include_.MergeFrom(from.include_);
  exclude_.MergeFrom(from.exclude_);
  loss_weight_.MergeFrom(from.loss_weight_);
  param_.MergeFrom(from.param_);
  blob_share_mode_.MergeFrom(from.blob_share_mode_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_layer()->::opencv_caffe::V0LayerParameter::MergeFrom(from.layer());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_concat_param()->::opencv_caffe::ConcatParameter::MergeFrom(from.concat_param());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_convolution_param()->::opencv_caffe::ConvolutionParameter::MergeFrom(from.convolution_param());
    }
    if (cached_has_bits & 0x00000010u) {
      mutable_data_param()->::opencv_caffe::DataParameter::MergeFrom(from.data_param());
    }
    if (cached_has_bits & 0x00000020u) {
      mutable_dropout_param()->::opencv_caffe::DropoutParameter::MergeFrom(from.dropout_param());
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_hdf5_data_param()->::opencv_caffe::HDF5DataParameter::MergeFrom(from.hdf5_data_param());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from.hdf5_output_param());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      mutable_image_data_param()->::opencv_caffe::ImageDataParameter::MergeFrom(from.image_data_param());
    }
    if (cached_has_bits & 0x00000200u) {
      mutable_infogain_loss_param()->::opencv_caffe::InfogainLossParameter::MergeFrom(from.infogain_loss_param());
    }
    if (cached_has_bits & 0x00000400u) {
      mutable_inner_product_param()->::opencv_caffe::InnerProductParameter::MergeFrom(from.inner_product_param());
    }
    if (cached_has_bits & 0x00000800u) {
      mutable_lrn_param()->::opencv_caffe::LRNParameter::MergeFrom(from.lrn_param());
    }
    if (cached_has_bits & 0x00001000u) {
      mutable_pooling_param()->::opencv_caffe::PoolingParameter::MergeFrom(from.pooling_param());
    }
    if (cached_has_bits & 0x00002000u) {
      mutable_window_data_param()->::opencv_caffe::WindowDataParameter::MergeFrom(from.window_data_param());
    }
    if (cached_has_bits & 0x00004000u) {
      mutable_power_param()->::opencv_caffe::PowerParameter::MergeFrom(from.power_param());
    }
    if (cached_has_bits & 0x00008000u) {
      mutable_memory_data_param()->::opencv_caffe::MemoryDataParameter::MergeFrom(from.memory_data_param());
    }
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      mutable_argmax_param()->::opencv_caffe::ArgMaxParameter::MergeFrom(from.argmax_param());
    }
    if (cached_has_bits & 0x00020000u) {
      mutable_eltwise_param()->::opencv_caffe::EltwiseParameter::MergeFrom(from.eltwise_param());
    }
    if (cached_has_bits & 0x00040000u) {
      mutable_threshold_param()->::opencv_caffe::ThresholdParameter::MergeFrom(from.threshold_param());
    }
    if (cached_has_bits & 0x00080000u) {
      mutable_dummy_data_param()->::opencv_caffe::DummyDataParameter::MergeFrom(from.dummy_data_param());
    }
    if (cached_has_bits & 0x00100000u) {
      mutable_accuracy_param()->::opencv_caffe::AccuracyParameter::MergeFrom(from.accuracy_param());
    }
    if (cached_has_bits & 0x00200000u) {
      mutable_hinge_loss_param()->::opencv_caffe::HingeLossParameter::MergeFrom(from.hinge_loss_param());
    }
    if (cached_has_bits & 0x00400000u) {
      mutable_relu_param()->::opencv_caffe::ReLUParameter::MergeFrom(from.relu_param());
    }
    if (cached_has_bits & 0x00800000u) {
      mutable_slice_param()->::opencv_caffe::SliceParameter::MergeFrom(from.slice_param());
    }
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      mutable_mvn_param()->::opencv_caffe::MVNParameter::MergeFrom(from.mvn_param());
    }
    if (cached_has_bits & 0x02000000u) {
      mutable_transform_param()->::opencv_caffe::TransformationParameter::MergeFrom(from.transform_param());
    }
    if (cached_has_bits & 0x04000000u) {
      mutable_tanh_param()->::opencv_caffe::TanHParameter::MergeFrom(from.tanh_param());
    }
    if (cached_has_bits & 0x08000000u) {
      mutable_sigmoid_param()->::opencv_caffe::SigmoidParameter::MergeFrom(from.sigmoid_param());
    }
    if (cached_has_bits & 0x10000000u) {
      mutable_softmax_param()->::opencv_caffe::SoftmaxParameter::MergeFrom(from.softmax_param());
    }
    if (cached_has_bits & 0x20000000u) {
      mutable_contrastive_loss_param()->::opencv_caffe::ContrastiveLossParameter::MergeFrom(from.contrastive_loss_param());
    }
    if (cached_has_bits & 0x40000000u) {
      mutable_exp_param()->::opencv_caffe::ExpParameter::MergeFrom(from.exp_param());
    }
    if (cached_has_bits & 0x80000000u) {
      mutable_loss_param()->::opencv_caffe::LossParameter::MergeFrom(from.loss_param());
    }
  }
  if (from.has_type()) {
    set_type(from.type());
  }
}

void V1LayerParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.V1LayerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void V1LayerParameter::CopyFrom(const V1LayerParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.V1LayerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool V1LayerParameter::IsInitialized() const {
  return true;
}

void V1LayerParameter::Swap(V1LayerParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void V1LayerParameter::InternalSwap(V1LayerParameter* other) {
  using std::swap;
  bottom_.InternalSwap(&other->bottom_);
  top_.InternalSwap(&other->top_);
  blobs_.InternalSwap(&other->blobs_);
  blobs_lr_.InternalSwap(&other->blobs_lr_);
  weight_decay_.InternalSwap(&other->weight_decay_);
  include_.InternalSwap(&other->include_);
  exclude_.InternalSwap(&other->exclude_);
  loss_weight_.InternalSwap(&other->loss_weight_);
  param_.InternalSwap(&other->param_);
  blob_share_mode_.InternalSwap(&other->blob_share_mode_);
  name_.Swap(&other->name_);
  swap(layer_, other->layer_);
  swap(concat_param_, other->concat_param_);
  swap(convolution_param_, other->convolution_param_);
  swap(data_param_, other->data_param_);
  swap(dropout_param_, other->dropout_param_);
  swap(hdf5_data_param_, other->hdf5_data_param_);
  swap(hdf5_output_param_, other->hdf5_output_param_);
  swap(image_data_param_, other->image_data_param_);
  swap(infogain_loss_param_, other->infogain_loss_param_);
  swap(inner_product_param_, other->inner_product_param_);
  swap(lrn_param_, other->lrn_param_);
  swap(pooling_param_, other->pooling_param_);
  swap(window_data_param_, other->window_data_param_);
  swap(power_param_, other->power_param_);
  swap(memory_data_param_, other->memory_data_param_);
  swap(argmax_param_, other->argmax_param_);
  swap(eltwise_param_, other->eltwise_param_);
  swap(threshold_param_, other->threshold_param_);
  swap(dummy_data_param_, other->dummy_data_param_);
  swap(accuracy_param_, other->accuracy_param_);
  swap(hinge_loss_param_, other->hinge_loss_param_);
  swap(relu_param_, other->relu_param_);
  swap(slice_param_, other->slice_param_);
  swap(mvn_param_, other->mvn_param_);
  swap(transform_param_, other->transform_param_);
  swap(tanh_param_, other->tanh_param_);
  swap(sigmoid_param_, other->sigmoid_param_);
  swap(softmax_param_, other->softmax_param_);
  swap(contrastive_loss_param_, other->contrastive_loss_param_);
  swap(exp_param_, other->exp_param_);
  swap(loss_param_, other->loss_param_);
  swap(type_, other->type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata V1LayerParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void V0LayerParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_V0LayerParameter_default_instance_._instance.get_mutable()->weight_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_V0LayerParameter_default_instance_._instance.get_mutable()->bias_filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
  ::opencv_caffe::_V0LayerParameter_default_instance_._instance.get_mutable()->hdf5_output_param_ = const_cast< ::opencv_caffe::HDF5OutputParameter*>(
      ::opencv_caffe::HDF5OutputParameter::internal_default_instance());
}
::google::protobuf::internal::ExplicitlyConstructed< ::std::string> V0LayerParameter::_default_det_crop_mode_;
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int V0LayerParameter::kNameFieldNumber;
const int V0LayerParameter::kTypeFieldNumber;
const int V0LayerParameter::kNumOutputFieldNumber;
const int V0LayerParameter::kBiastermFieldNumber;
const int V0LayerParameter::kWeightFillerFieldNumber;
const int V0LayerParameter::kBiasFillerFieldNumber;
const int V0LayerParameter::kPadFieldNumber;
const int V0LayerParameter::kKernelsizeFieldNumber;
const int V0LayerParameter::kGroupFieldNumber;
const int V0LayerParameter::kStrideFieldNumber;
const int V0LayerParameter::kPoolFieldNumber;
const int V0LayerParameter::kDropoutRatioFieldNumber;
const int V0LayerParameter::kLocalSizeFieldNumber;
const int V0LayerParameter::kAlphaFieldNumber;
const int V0LayerParameter::kBetaFieldNumber;
const int V0LayerParameter::kKFieldNumber;
const int V0LayerParameter::kSourceFieldNumber;
const int V0LayerParameter::kScaleFieldNumber;
const int V0LayerParameter::kMeanfileFieldNumber;
const int V0LayerParameter::kBatchsizeFieldNumber;
const int V0LayerParameter::kCropsizeFieldNumber;
const int V0LayerParameter::kMirrorFieldNumber;
const int V0LayerParameter::kBlobsFieldNumber;
const int V0LayerParameter::kBlobsLrFieldNumber;
const int V0LayerParameter::kWeightDecayFieldNumber;
const int V0LayerParameter::kRandSkipFieldNumber;
const int V0LayerParameter::kDetFgThresholdFieldNumber;
const int V0LayerParameter::kDetBgThresholdFieldNumber;
const int V0LayerParameter::kDetFgFractionFieldNumber;
const int V0LayerParameter::kDetContextPadFieldNumber;
const int V0LayerParameter::kDetCropModeFieldNumber;
const int V0LayerParameter::kNewNumFieldNumber;
const int V0LayerParameter::kNewChannelsFieldNumber;
const int V0LayerParameter::kNewHeightFieldNumber;
const int V0LayerParameter::kNewWidthFieldNumber;
const int V0LayerParameter::kShuffleImagesFieldNumber;
const int V0LayerParameter::kConcatDimFieldNumber;
const int V0LayerParameter::kHdf5OutputParamFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

V0LayerParameter::V0LayerParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsV0LayerParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.V0LayerParameter)
}
V0LayerParameter::V0LayerParameter(const V0LayerParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      blobs_(from.blobs_),
      blobs_lr_(from.blobs_lr_),
      weight_decay_(from.weight_decay_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_type()) {
    type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
  }
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_source()) {
    source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
  }
  meanfile_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_meanfile()) {
    meanfile_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.meanfile_);
  }
  det_crop_mode_.UnsafeSetDefault(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
  if (from.has_det_crop_mode()) {
    det_crop_mode_.AssignWithDefault(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(), from.det_crop_mode_);
  }
  if (from.has_weight_filler()) {
    weight_filler_ = new ::opencv_caffe::FillerParameter(*from.weight_filler_);
  } else {
    weight_filler_ = NULL;
  }
  if (from.has_bias_filler()) {
    bias_filler_ = new ::opencv_caffe::FillerParameter(*from.bias_filler_);
  } else {
    bias_filler_ = NULL;
  }
  if (from.has_hdf5_output_param()) {
    hdf5_output_param_ = new ::opencv_caffe::HDF5OutputParameter(*from.hdf5_output_param_);
  } else {
    hdf5_output_param_ = NULL;
  }
  ::memcpy(&num_output_, &from.num_output_,
    static_cast<size_t>(reinterpret_cast<char*>(&det_fg_fraction_) -
    reinterpret_cast<char*>(&num_output_)) + sizeof(det_fg_fraction_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.V0LayerParameter)
}

void V0LayerParameter::SharedCtor() {
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  source_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  meanfile_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  det_crop_mode_.UnsafeSetDefault(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
  ::memset(&weight_filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&new_height_) -
      reinterpret_cast<char*>(&weight_filler_)) + sizeof(new_height_));
  concat_dim_ = 1u;
  biasterm_ = true;
  group_ = 1u;
  stride_ = 1u;
  dropout_ratio_ = 0.5f;
  local_size_ = 5u;
  alpha_ = 1;
  beta_ = 0.75f;
  scale_ = 1;
  k_ = 1;
  det_fg_threshold_ = 0.5f;
  det_bg_threshold_ = 0.5f;
  det_fg_fraction_ = 0.25f;
  _cached_size_ = 0;
}

V0LayerParameter::~V0LayerParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.V0LayerParameter)
  SharedDtor();
}

void V0LayerParameter::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  source_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  meanfile_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  det_crop_mode_.DestroyNoArena(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
  if (this != internal_default_instance()) delete weight_filler_;
  if (this != internal_default_instance()) delete bias_filler_;
  if (this != internal_default_instance()) delete hdf5_output_param_;
}

void V0LayerParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* V0LayerParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const V0LayerParameter& V0LayerParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsV0LayerParameter();
  return *internal_default_instance();
}

V0LayerParameter* V0LayerParameter::New(::google::protobuf::Arena* arena) const {
  V0LayerParameter* n = new V0LayerParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void V0LayerParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.V0LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  blobs_.Clear();
  blobs_lr_.Clear();
  weight_decay_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*name_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(!type_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*type_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(!source_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*source_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(!meanfile_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*meanfile_.UnsafeRawStringPointer())->clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(!det_crop_mode_.IsDefault(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get()));
      (*det_crop_mode_.UnsafeRawStringPointer())->assign(*&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get());
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(weight_filler_ != NULL);
      weight_filler_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(bias_filler_ != NULL);
      bias_filler_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(hdf5_output_param_ != NULL);
      hdf5_output_param_->Clear();
    }
  }
  if (cached_has_bits & 65280u) {
    ::memset(&num_output_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&mirror_) -
        reinterpret_cast<char*>(&num_output_)) + sizeof(mirror_));
  }
  if (cached_has_bits & 16711680u) {
    ::memset(&shuffle_images_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&new_height_) -
        reinterpret_cast<char*>(&shuffle_images_)) + sizeof(new_height_));
    concat_dim_ = 1u;
    biasterm_ = true;
  }
  if (cached_has_bits & 4278190080u) {
    group_ = 1u;
    stride_ = 1u;
    dropout_ratio_ = 0.5f;
    local_size_ = 5u;
    alpha_ = 1;
    beta_ = 0.75f;
    scale_ = 1;
    k_ = 1;
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 7u) {
    det_fg_threshold_ = 0.5f;
    det_bg_threshold_ = 0.5f;
    det_fg_fraction_ = 0.25f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool V0LayerParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.V0LayerParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), static_cast<int>(this->name().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V0LayerParameter.name");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string type = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_type()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->type().data(), static_cast<int>(this->type().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V0LayerParameter.type");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 num_output = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_num_output();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_output_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool biasterm = 4 [default = true];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          set_has_biasterm();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &biasterm_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter weight_filler = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_weight_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.FillerParameter bias_filler = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_bias_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pad = 7 [default = 0];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_pad();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pad_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 kernelsize = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          set_has_kernelsize();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kernelsize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 group = 9 [default = 1];
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_group();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &group_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 stride = 10 [default = 1];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_stride();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stride_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::opencv_caffe::V0LayerParameter_PoolMethod_IsValid(value)) {
            set_pool(static_cast< ::opencv_caffe::V0LayerParameter_PoolMethod >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                11, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float dropout_ratio = 12 [default = 0.5];
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(101u /* 101 & 0xFF */)) {
          set_has_dropout_ratio();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &dropout_ratio_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 local_size = 13 [default = 5];
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) {
          set_has_local_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &local_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float alpha = 14 [default = 1];
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(117u /* 117 & 0xFF */)) {
          set_has_alpha();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &alpha_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float beta = 15 [default = 0.75];
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(125u /* 125 & 0xFF */)) {
          set_has_beta();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &beta_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string source = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(130u /* 130 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_source()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->source().data(), static_cast<int>(this->source().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V0LayerParameter.source");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float scale = 17 [default = 1];
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(141u /* 141 & 0xFF */)) {
          set_has_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string meanfile = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 146 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_meanfile()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->meanfile().data(), static_cast<int>(this->meanfile().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V0LayerParameter.meanfile");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 batchsize = 19;
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(152u /* 152 & 0xFF */)) {
          set_has_batchsize();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &batchsize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 cropsize = 20 [default = 0];
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(160u /* 160 & 0xFF */)) {
          set_has_cropsize();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &cropsize_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool mirror = 21 [default = false];
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(168u /* 168 & 0xFF */)) {
          set_has_mirror();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &mirror_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float k = 22 [default = 1];
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(181u /* 181 & 0xFF */)) {
          set_has_k();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &k_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .opencv_caffe.BlobProto blobs = 50;
      case 50: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 402 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_blobs()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float blobs_lr = 51;
      case 51: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(157u /* 413 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 2, 413u, input, this->mutable_blobs_lr())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(154u /* 410 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_blobs_lr())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float weight_decay = 52;
      case 52: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(165u /* 421 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 2, 421u, input, this->mutable_weight_decay())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(162u /* 418 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_weight_decay())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 rand_skip = 53 [default = 0];
      case 53: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(168u /* 424 & 0xFF */)) {
          set_has_rand_skip();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rand_skip_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float det_fg_threshold = 54 [default = 0.5];
      case 54: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(181u /* 437 & 0xFF */)) {
          set_has_det_fg_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &det_fg_threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float det_bg_threshold = 55 [default = 0.5];
      case 55: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(189u /* 445 & 0xFF */)) {
          set_has_det_bg_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &det_bg_threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float det_fg_fraction = 56 [default = 0.25];
      case 56: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(197u /* 453 & 0xFF */)) {
          set_has_det_fg_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &det_fg_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 det_context_pad = 58 [default = 0];
      case 58: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(208u /* 464 & 0xFF */)) {
          set_has_det_context_pad();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &det_context_pad_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string det_crop_mode = 59 [default = "warp"];
      case 59: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(218u /* 474 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_det_crop_mode()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->det_crop_mode().data(), static_cast<int>(this->det_crop_mode().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "opencv_caffe.V0LayerParameter.det_crop_mode");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 new_num = 60 [default = 0];
      case 60: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(224u /* 480 & 0xFF */)) {
          set_has_new_num();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &new_num_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 new_channels = 61 [default = 0];
      case 61: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(232u /* 488 & 0xFF */)) {
          set_has_new_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &new_channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 new_height = 62 [default = 0];
      case 62: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(240u /* 496 & 0xFF */)) {
          set_has_new_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &new_height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 new_width = 63 [default = 0];
      case 63: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(248u /* 504 & 0xFF */)) {
          set_has_new_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &new_width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool shuffle_images = 64 [default = false];
      case 64: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(0u /* 512 & 0xFF */)) {
          set_has_shuffle_images();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &shuffle_images_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 concat_dim = 65 [default = 1];
      case 65: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 520 & 0xFF */)) {
          set_has_concat_dim();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &concat_dim_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
      case 1001: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 8010 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_hdf5_output_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.V0LayerParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.V0LayerParameter)
  return false;
#undef DO_
}

void V0LayerParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.V0LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional string type = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.type");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->type(), output);
  }

  // optional uint32 num_output = 3;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->num_output(), output);
  }

  // optional bool biasterm = 4 [default = true];
  if (cached_has_bits & 0x00800000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->biasterm(), output);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 5;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->weight_filler_, output);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 6;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, *this->bias_filler_, output);
  }

  // optional uint32 pad = 7 [default = 0];
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->pad(), output);
  }

  // optional uint32 kernelsize = 8;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->kernelsize(), output);
  }

  // optional uint32 group = 9 [default = 1];
  if (cached_has_bits & 0x01000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->group(), output);
  }

  // optional uint32 stride = 10 [default = 1];
  if (cached_has_bits & 0x02000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->stride(), output);
  }

  // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      11, this->pool(), output);
  }

  // optional float dropout_ratio = 12 [default = 0.5];
  if (cached_has_bits & 0x04000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->dropout_ratio(), output);
  }

  // optional uint32 local_size = 13 [default = 5];
  if (cached_has_bits & 0x08000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->local_size(), output);
  }

  // optional float alpha = 14 [default = 1];
  if (cached_has_bits & 0x10000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(14, this->alpha(), output);
  }

  // optional float beta = 15 [default = 0.75];
  if (cached_has_bits & 0x20000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(15, this->beta(), output);
  }

  // optional string source = 16;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.source");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      16, this->source(), output);
  }

  // optional float scale = 17 [default = 1];
  if (cached_has_bits & 0x40000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(17, this->scale(), output);
  }

  // optional string meanfile = 18;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->meanfile().data(), static_cast<int>(this->meanfile().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.meanfile");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      18, this->meanfile(), output);
  }

  // optional uint32 batchsize = 19;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(19, this->batchsize(), output);
  }

  // optional uint32 cropsize = 20 [default = 0];
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(20, this->cropsize(), output);
  }

  // optional bool mirror = 21 [default = false];
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(21, this->mirror(), output);
  }

  // optional float k = 22 [default = 1];
  if (cached_has_bits & 0x80000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(22, this->k(), output);
  }

  // repeated .opencv_caffe.BlobProto blobs = 50;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      50, this->blobs(static_cast<int>(i)), output);
  }

  // repeated float blobs_lr = 51;
  for (int i = 0, n = this->blobs_lr_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      51, this->blobs_lr(i), output);
  }

  // repeated float weight_decay = 52;
  for (int i = 0, n = this->weight_decay_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      52, this->weight_decay(i), output);
  }

  // optional uint32 rand_skip = 53 [default = 0];
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(53, this->rand_skip(), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional float det_fg_threshold = 54 [default = 0.5];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(54, this->det_fg_threshold(), output);
  }

  // optional float det_bg_threshold = 55 [default = 0.5];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(55, this->det_bg_threshold(), output);
  }

  // optional float det_fg_fraction = 56 [default = 0.25];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(56, this->det_fg_fraction(), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional uint32 det_context_pad = 58 [default = 0];
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(58, this->det_context_pad(), output);
  }

  // optional string det_crop_mode = 59 [default = "warp"];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->det_crop_mode().data(), static_cast<int>(this->det_crop_mode().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.det_crop_mode");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      59, this->det_crop_mode(), output);
  }

  // optional int32 new_num = 60 [default = 0];
  if (cached_has_bits & 0x00080000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(60, this->new_num(), output);
  }

  // optional int32 new_channels = 61 [default = 0];
  if (cached_has_bits & 0x00100000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(61, this->new_channels(), output);
  }

  // optional int32 new_height = 62 [default = 0];
  if (cached_has_bits & 0x00200000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(62, this->new_height(), output);
  }

  // optional int32 new_width = 63 [default = 0];
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(63, this->new_width(), output);
  }

  // optional bool shuffle_images = 64 [default = false];
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(64, this->shuffle_images(), output);
  }

  // optional uint32 concat_dim = 65 [default = 1];
  if (cached_has_bits & 0x00400000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(65, this->concat_dim(), output);
  }

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1001, *this->hdf5_output_param_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.V0LayerParameter)
}

::google::protobuf::uint8* V0LayerParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.V0LayerParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), static_cast<int>(this->name().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional string type = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->type().data(), static_cast<int>(this->type().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.type");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->type(), target);
  }

  // optional uint32 num_output = 3;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->num_output(), target);
  }

  // optional bool biasterm = 4 [default = true];
  if (cached_has_bits & 0x00800000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->biasterm(), target);
  }

  // optional .opencv_caffe.FillerParameter weight_filler = 5;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, *this->weight_filler_, deterministic, target);
  }

  // optional .opencv_caffe.FillerParameter bias_filler = 6;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, *this->bias_filler_, deterministic, target);
  }

  // optional uint32 pad = 7 [default = 0];
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->pad(), target);
  }

  // optional uint32 kernelsize = 8;
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->kernelsize(), target);
  }

  // optional uint32 group = 9 [default = 1];
  if (cached_has_bits & 0x01000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->group(), target);
  }

  // optional uint32 stride = 10 [default = 1];
  if (cached_has_bits & 0x02000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->stride(), target);
  }

  // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      11, this->pool(), target);
  }

  // optional float dropout_ratio = 12 [default = 0.5];
  if (cached_has_bits & 0x04000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->dropout_ratio(), target);
  }

  // optional uint32 local_size = 13 [default = 5];
  if (cached_has_bits & 0x08000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->local_size(), target);
  }

  // optional float alpha = 14 [default = 1];
  if (cached_has_bits & 0x10000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(14, this->alpha(), target);
  }

  // optional float beta = 15 [default = 0.75];
  if (cached_has_bits & 0x20000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(15, this->beta(), target);
  }

  // optional string source = 16;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->source().data(), static_cast<int>(this->source().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.source");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        16, this->source(), target);
  }

  // optional float scale = 17 [default = 1];
  if (cached_has_bits & 0x40000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(17, this->scale(), target);
  }

  // optional string meanfile = 18;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->meanfile().data(), static_cast<int>(this->meanfile().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.meanfile");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        18, this->meanfile(), target);
  }

  // optional uint32 batchsize = 19;
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(19, this->batchsize(), target);
  }

  // optional uint32 cropsize = 20 [default = 0];
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(20, this->cropsize(), target);
  }

  // optional bool mirror = 21 [default = false];
  if (cached_has_bits & 0x00008000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(21, this->mirror(), target);
  }

  // optional float k = 22 [default = 1];
  if (cached_has_bits & 0x80000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(22, this->k(), target);
  }

  // repeated .opencv_caffe.BlobProto blobs = 50;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->blobs_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        50, this->blobs(static_cast<int>(i)), deterministic, target);
  }

  // repeated float blobs_lr = 51;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(51, this->blobs_lr_, target);

  // repeated float weight_decay = 52;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(52, this->weight_decay_, target);

  // optional uint32 rand_skip = 53 [default = 0];
  if (cached_has_bits & 0x00020000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(53, this->rand_skip(), target);
  }

  cached_has_bits = _has_bits_[1];
  // optional float det_fg_threshold = 54 [default = 0.5];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(54, this->det_fg_threshold(), target);
  }

  // optional float det_bg_threshold = 55 [default = 0.5];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(55, this->det_bg_threshold(), target);
  }

  // optional float det_fg_fraction = 56 [default = 0.25];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(56, this->det_fg_fraction(), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional uint32 det_context_pad = 58 [default = 0];
  if (cached_has_bits & 0x00040000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(58, this->det_context_pad(), target);
  }

  // optional string det_crop_mode = 59 [default = "warp"];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->det_crop_mode().data(), static_cast<int>(this->det_crop_mode().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "opencv_caffe.V0LayerParameter.det_crop_mode");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        59, this->det_crop_mode(), target);
  }

  // optional int32 new_num = 60 [default = 0];
  if (cached_has_bits & 0x00080000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(60, this->new_num(), target);
  }

  // optional int32 new_channels = 61 [default = 0];
  if (cached_has_bits & 0x00100000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(61, this->new_channels(), target);
  }

  // optional int32 new_height = 62 [default = 0];
  if (cached_has_bits & 0x00200000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(62, this->new_height(), target);
  }

  // optional int32 new_width = 63 [default = 0];
  if (cached_has_bits & 0x00004000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(63, this->new_width(), target);
  }

  // optional bool shuffle_images = 64 [default = false];
  if (cached_has_bits & 0x00010000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(64, this->shuffle_images(), target);
  }

  // optional uint32 concat_dim = 65 [default = 1];
  if (cached_has_bits & 0x00400000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(65, this->concat_dim(), target);
  }

  // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1001, *this->hdf5_output_param_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.V0LayerParameter)
  return target;
}

size_t V0LayerParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.V0LayerParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .opencv_caffe.BlobProto blobs = 50;
  {
    unsigned int count = static_cast<unsigned int>(this->blobs_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->blobs(static_cast<int>(i)));
    }
  }

  // repeated float blobs_lr = 51;
  {
    unsigned int count = static_cast<unsigned int>(this->blobs_lr_size());
    size_t data_size = 4UL * count;
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->blobs_lr_size());
    total_size += data_size;
  }

  // repeated float weight_decay = 52;
  {
    unsigned int count = static_cast<unsigned int>(this->weight_decay_size());
    size_t data_size = 4UL * count;
    total_size += 2 *
                  ::google::protobuf::internal::FromIntSize(this->weight_decay_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string type = 2;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->type());
    }

    // optional string source = 16;
    if (has_source()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->source());
    }

    // optional string meanfile = 18;
    if (has_meanfile()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->meanfile());
    }

    // optional string det_crop_mode = 59 [default = "warp"];
    if (has_det_crop_mode()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->det_crop_mode());
    }

    // optional .opencv_caffe.FillerParameter weight_filler = 5;
    if (has_weight_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->weight_filler_);
    }

    // optional .opencv_caffe.FillerParameter bias_filler = 6;
    if (has_bias_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->bias_filler_);
    }

    // optional .opencv_caffe.HDF5OutputParameter hdf5_output_param = 1001;
    if (has_hdf5_output_param()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->hdf5_output_param_);
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional uint32 num_output = 3;
    if (has_num_output()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_output());
    }

    // optional uint32 pad = 7 [default = 0];
    if (has_pad()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pad());
    }

    // optional uint32 kernelsize = 8;
    if (has_kernelsize()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kernelsize());
    }

    // optional .opencv_caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
    if (has_pool()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->pool());
    }

    // optional uint32 batchsize = 19;
    if (has_batchsize()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->batchsize());
    }

    // optional uint32 cropsize = 20 [default = 0];
    if (has_cropsize()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->cropsize());
    }

    // optional int32 new_width = 63 [default = 0];
    if (has_new_width()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->new_width());
    }

    // optional bool mirror = 21 [default = false];
    if (has_mirror()) {
      total_size += 2 + 1;
    }

  }
  if (_has_bits_[16 / 32] & 16711680u) {
    // optional bool shuffle_images = 64 [default = false];
    if (has_shuffle_images()) {
      total_size += 2 + 1;
    }

    // optional uint32 rand_skip = 53 [default = 0];
    if (has_rand_skip()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->rand_skip());
    }

    // optional uint32 det_context_pad = 58 [default = 0];
    if (has_det_context_pad()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->det_context_pad());
    }

    // optional int32 new_num = 60 [default = 0];
    if (has_new_num()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->new_num());
    }

    // optional int32 new_channels = 61 [default = 0];
    if (has_new_channels()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->new_channels());
    }

    // optional int32 new_height = 62 [default = 0];
    if (has_new_height()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->new_height());
    }

    // optional uint32 concat_dim = 65 [default = 1];
    if (has_concat_dim()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->concat_dim());
    }

    // optional bool biasterm = 4 [default = true];
    if (has_biasterm()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[24 / 32] & 4278190080u) {
    // optional uint32 group = 9 [default = 1];
    if (has_group()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->group());
    }

    // optional uint32 stride = 10 [default = 1];
    if (has_stride()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stride());
    }

    // optional float dropout_ratio = 12 [default = 0.5];
    if (has_dropout_ratio()) {
      total_size += 1 + 4;
    }

    // optional uint32 local_size = 13 [default = 5];
    if (has_local_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->local_size());
    }

    // optional float alpha = 14 [default = 1];
    if (has_alpha()) {
      total_size += 1 + 4;
    }

    // optional float beta = 15 [default = 0.75];
    if (has_beta()) {
      total_size += 1 + 4;
    }

    // optional float scale = 17 [default = 1];
    if (has_scale()) {
      total_size += 2 + 4;
    }

    // optional float k = 22 [default = 1];
    if (has_k()) {
      total_size += 2 + 4;
    }

  }
  if (_has_bits_[32 / 32] & 7u) {
    // optional float det_fg_threshold = 54 [default = 0.5];
    if (has_det_fg_threshold()) {
      total_size += 2 + 4;
    }

    // optional float det_bg_threshold = 55 [default = 0.5];
    if (has_det_bg_threshold()) {
      total_size += 2 + 4;
    }

    // optional float det_fg_fraction = 56 [default = 0.25];
    if (has_det_fg_fraction()) {
      total_size += 2 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void V0LayerParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.V0LayerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const V0LayerParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const V0LayerParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.V0LayerParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.V0LayerParameter)
    MergeFrom(*source);
  }
}

void V0LayerParameter::MergeFrom(const V0LayerParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.V0LayerParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  blobs_.MergeFrom(from.blobs_);
  blobs_lr_.MergeFrom(from.blobs_lr_);
  weight_decay_.MergeFrom(from.weight_decay_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_type();
      type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_source();
      source_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.source_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_meanfile();
      meanfile_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.meanfile_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_det_crop_mode();
      det_crop_mode_.AssignWithDefault(&::opencv_caffe::V0LayerParameter::_default_det_crop_mode_.get(), from.det_crop_mode_);
    }
    if (cached_has_bits & 0x00000020u) {
      mutable_weight_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.weight_filler());
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_bias_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.bias_filler());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_hdf5_output_param()->::opencv_caffe::HDF5OutputParameter::MergeFrom(from.hdf5_output_param());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      num_output_ = from.num_output_;
    }
    if (cached_has_bits & 0x00000200u) {
      pad_ = from.pad_;
    }
    if (cached_has_bits & 0x00000400u) {
      kernelsize_ = from.kernelsize_;
    }
    if (cached_has_bits & 0x00000800u) {
      pool_ = from.pool_;
    }
    if (cached_has_bits & 0x00001000u) {
      batchsize_ = from.batchsize_;
    }
    if (cached_has_bits & 0x00002000u) {
      cropsize_ = from.cropsize_;
    }
    if (cached_has_bits & 0x00004000u) {
      new_width_ = from.new_width_;
    }
    if (cached_has_bits & 0x00008000u) {
      mirror_ = from.mirror_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      shuffle_images_ = from.shuffle_images_;
    }
    if (cached_has_bits & 0x00020000u) {
      rand_skip_ = from.rand_skip_;
    }
    if (cached_has_bits & 0x00040000u) {
      det_context_pad_ = from.det_context_pad_;
    }
    if (cached_has_bits & 0x00080000u) {
      new_num_ = from.new_num_;
    }
    if (cached_has_bits & 0x00100000u) {
      new_channels_ = from.new_channels_;
    }
    if (cached_has_bits & 0x00200000u) {
      new_height_ = from.new_height_;
    }
    if (cached_has_bits & 0x00400000u) {
      concat_dim_ = from.concat_dim_;
    }
    if (cached_has_bits & 0x00800000u) {
      biasterm_ = from.biasterm_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      group_ = from.group_;
    }
    if (cached_has_bits & 0x02000000u) {
      stride_ = from.stride_;
    }
    if (cached_has_bits & 0x04000000u) {
      dropout_ratio_ = from.dropout_ratio_;
    }
    if (cached_has_bits & 0x08000000u) {
      local_size_ = from.local_size_;
    }
    if (cached_has_bits & 0x10000000u) {
      alpha_ = from.alpha_;
    }
    if (cached_has_bits & 0x20000000u) {
      beta_ = from.beta_;
    }
    if (cached_has_bits & 0x40000000u) {
      scale_ = from.scale_;
    }
    if (cached_has_bits & 0x80000000u) {
      k_ = from.k_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[1];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      det_fg_threshold_ = from.det_fg_threshold_;
    }
    if (cached_has_bits & 0x00000002u) {
      det_bg_threshold_ = from.det_bg_threshold_;
    }
    if (cached_has_bits & 0x00000004u) {
      det_fg_fraction_ = from.det_fg_fraction_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
}

void V0LayerParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.V0LayerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void V0LayerParameter::CopyFrom(const V0LayerParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.V0LayerParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool V0LayerParameter::IsInitialized() const {
  return true;
}

void V0LayerParameter::Swap(V0LayerParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void V0LayerParameter::InternalSwap(V0LayerParameter* other) {
  using std::swap;
  blobs_.InternalSwap(&other->blobs_);
  blobs_lr_.InternalSwap(&other->blobs_lr_);
  weight_decay_.InternalSwap(&other->weight_decay_);
  name_.Swap(&other->name_);
  type_.Swap(&other->type_);
  source_.Swap(&other->source_);
  meanfile_.Swap(&other->meanfile_);
  det_crop_mode_.Swap(&other->det_crop_mode_);
  swap(weight_filler_, other->weight_filler_);
  swap(bias_filler_, other->bias_filler_);
  swap(hdf5_output_param_, other->hdf5_output_param_);
  swap(num_output_, other->num_output_);
  swap(pad_, other->pad_);
  swap(kernelsize_, other->kernelsize_);
  swap(pool_, other->pool_);
  swap(batchsize_, other->batchsize_);
  swap(cropsize_, other->cropsize_);
  swap(new_width_, other->new_width_);
  swap(mirror_, other->mirror_);
  swap(shuffle_images_, other->shuffle_images_);
  swap(rand_skip_, other->rand_skip_);
  swap(det_context_pad_, other->det_context_pad_);
  swap(new_num_, other->new_num_);
  swap(new_channels_, other->new_channels_);
  swap(new_height_, other->new_height_);
  swap(concat_dim_, other->concat_dim_);
  swap(biasterm_, other->biasterm_);
  swap(group_, other->group_);
  swap(stride_, other->stride_);
  swap(dropout_ratio_, other->dropout_ratio_);
  swap(local_size_, other->local_size_);
  swap(alpha_, other->alpha_);
  swap(beta_, other->beta_);
  swap(scale_, other->scale_);
  swap(k_, other->k_);
  swap(det_fg_threshold_, other->det_fg_threshold_);
  swap(det_bg_threshold_, other->det_bg_threshold_);
  swap(det_fg_fraction_, other->det_fg_fraction_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata V0LayerParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PReLUParameter::InitAsDefaultInstance() {
  ::opencv_caffe::_PReLUParameter_default_instance_._instance.get_mutable()->filler_ = const_cast< ::opencv_caffe::FillerParameter*>(
      ::opencv_caffe::FillerParameter::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PReLUParameter::kFillerFieldNumber;
const int PReLUParameter::kChannelSharedFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PReLUParameter::PReLUParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPReLUParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PReLUParameter)
}
PReLUParameter::PReLUParameter(const PReLUParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_filler()) {
    filler_ = new ::opencv_caffe::FillerParameter(*from.filler_);
  } else {
    filler_ = NULL;
  }
  channel_shared_ = from.channel_shared_;
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PReLUParameter)
}

void PReLUParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&filler_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&channel_shared_) -
      reinterpret_cast<char*>(&filler_)) + sizeof(channel_shared_));
}

PReLUParameter::~PReLUParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PReLUParameter)
  SharedDtor();
}

void PReLUParameter::SharedDtor() {
  if (this != internal_default_instance()) delete filler_;
}

void PReLUParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PReLUParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PReLUParameter& PReLUParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPReLUParameter();
  return *internal_default_instance();
}

PReLUParameter* PReLUParameter::New(::google::protobuf::Arena* arena) const {
  PReLUParameter* n = new PReLUParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PReLUParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PReLUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(filler_ != NULL);
    filler_->Clear();
  }
  channel_shared_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PReLUParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PReLUParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .opencv_caffe.FillerParameter filler = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_filler()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool channel_shared = 2 [default = false];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_channel_shared();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &channel_shared_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PReLUParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PReLUParameter)
  return false;
#undef DO_
}

void PReLUParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PReLUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.FillerParameter filler = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->filler_, output);
  }

  // optional bool channel_shared = 2 [default = false];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->channel_shared(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PReLUParameter)
}

::google::protobuf::uint8* PReLUParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PReLUParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .opencv_caffe.FillerParameter filler = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->filler_, deterministic, target);
  }

  // optional bool channel_shared = 2 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->channel_shared(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PReLUParameter)
  return target;
}

size_t PReLUParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PReLUParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional .opencv_caffe.FillerParameter filler = 1;
    if (has_filler()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->filler_);
    }

    // optional bool channel_shared = 2 [default = false];
    if (has_channel_shared()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PReLUParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PReLUParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PReLUParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PReLUParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PReLUParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PReLUParameter)
    MergeFrom(*source);
  }
}

void PReLUParameter::MergeFrom(const PReLUParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PReLUParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_filler()->::opencv_caffe::FillerParameter::MergeFrom(from.filler());
    }
    if (cached_has_bits & 0x00000002u) {
      channel_shared_ = from.channel_shared_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PReLUParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PReLUParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PReLUParameter::CopyFrom(const PReLUParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PReLUParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PReLUParameter::IsInitialized() const {
  return true;
}

void PReLUParameter::Swap(PReLUParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PReLUParameter::InternalSwap(PReLUParameter* other) {
  using std::swap;
  swap(filler_, other->filler_);
  swap(channel_shared_, other->channel_shared_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PReLUParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void NormalizedBBox::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NormalizedBBox::kXminFieldNumber;
const int NormalizedBBox::kYminFieldNumber;
const int NormalizedBBox::kXmaxFieldNumber;
const int NormalizedBBox::kYmaxFieldNumber;
const int NormalizedBBox::kLabelFieldNumber;
const int NormalizedBBox::kDifficultFieldNumber;
const int NormalizedBBox::kScoreFieldNumber;
const int NormalizedBBox::kSizeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NormalizedBBox::NormalizedBBox()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizedBBox();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.NormalizedBBox)
}
NormalizedBBox::NormalizedBBox(const NormalizedBBox& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&xmin_, &from.xmin_,
    static_cast<size_t>(reinterpret_cast<char*>(&size_) -
    reinterpret_cast<char*>(&xmin_)) + sizeof(size_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.NormalizedBBox)
}

void NormalizedBBox::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&xmin_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&xmin_)) + sizeof(size_));
}

NormalizedBBox::~NormalizedBBox() {
  // @@protoc_insertion_point(destructor:opencv_caffe.NormalizedBBox)
  SharedDtor();
}

void NormalizedBBox::SharedDtor() {
}

void NormalizedBBox::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NormalizedBBox::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const NormalizedBBox& NormalizedBBox::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsNormalizedBBox();
  return *internal_default_instance();
}

NormalizedBBox* NormalizedBBox::New(::google::protobuf::Arena* arena) const {
  NormalizedBBox* n = new NormalizedBBox;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NormalizedBBox::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.NormalizedBBox)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    ::memset(&xmin_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&size_) -
        reinterpret_cast<char*>(&xmin_)) + sizeof(size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool NormalizedBBox::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.NormalizedBBox)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float xmin = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_xmin();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &xmin_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float ymin = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) {
          set_has_ymin();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &ymin_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float xmax = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_xmax();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &xmax_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float ymax = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
          set_has_ymax();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &ymax_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 label = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_label();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &label_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool difficult = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_difficult();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &difficult_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float score = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(61u /* 61 & 0xFF */)) {
          set_has_score();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &score_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float size = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(69u /* 69 & 0xFF */)) {
          set_has_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.NormalizedBBox)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.NormalizedBBox)
  return false;
#undef DO_
}

void NormalizedBBox::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.NormalizedBBox)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float xmin = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->xmin(), output);
  }

  // optional float ymin = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->ymin(), output);
  }

  // optional float xmax = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->xmax(), output);
  }

  // optional float ymax = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->ymax(), output);
  }

  // optional int32 label = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->label(), output);
  }

  // optional bool difficult = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->difficult(), output);
  }

  // optional float score = 7;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->score(), output);
  }

  // optional float size = 8;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.NormalizedBBox)
}

::google::protobuf::uint8* NormalizedBBox::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.NormalizedBBox)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float xmin = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->xmin(), target);
  }

  // optional float ymin = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->ymin(), target);
  }

  // optional float xmax = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->xmax(), target);
  }

  // optional float ymax = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->ymax(), target);
  }

  // optional int32 label = 5;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->label(), target);
  }

  // optional bool difficult = 6;
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->difficult(), target);
  }

  // optional float score = 7;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->score(), target);
  }

  // optional float size = 8;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.NormalizedBBox)
  return target;
}

size_t NormalizedBBox::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.NormalizedBBox)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 255u) {
    // optional float xmin = 1;
    if (has_xmin()) {
      total_size += 1 + 4;
    }

    // optional float ymin = 2;
    if (has_ymin()) {
      total_size += 1 + 4;
    }

    // optional float xmax = 3;
    if (has_xmax()) {
      total_size += 1 + 4;
    }

    // optional float ymax = 4;
    if (has_ymax()) {
      total_size += 1 + 4;
    }

    // optional int32 label = 5;
    if (has_label()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->label());
    }

    // optional bool difficult = 6;
    if (has_difficult()) {
      total_size += 1 + 1;
    }

    // optional float score = 7;
    if (has_score()) {
      total_size += 1 + 4;
    }

    // optional float size = 8;
    if (has_size()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NormalizedBBox::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.NormalizedBBox)
  GOOGLE_DCHECK_NE(&from, this);
  const NormalizedBBox* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NormalizedBBox>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.NormalizedBBox)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.NormalizedBBox)
    MergeFrom(*source);
  }
}

void NormalizedBBox::MergeFrom(const NormalizedBBox& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.NormalizedBBox)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      xmin_ = from.xmin_;
    }
    if (cached_has_bits & 0x00000002u) {
      ymin_ = from.ymin_;
    }
    if (cached_has_bits & 0x00000004u) {
      xmax_ = from.xmax_;
    }
    if (cached_has_bits & 0x00000008u) {
      ymax_ = from.ymax_;
    }
    if (cached_has_bits & 0x00000010u) {
      label_ = from.label_;
    }
    if (cached_has_bits & 0x00000020u) {
      difficult_ = from.difficult_;
    }
    if (cached_has_bits & 0x00000040u) {
      score_ = from.score_;
    }
    if (cached_has_bits & 0x00000080u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void NormalizedBBox::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.NormalizedBBox)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NormalizedBBox::CopyFrom(const NormalizedBBox& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.NormalizedBBox)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NormalizedBBox::IsInitialized() const {
  return true;
}

void NormalizedBBox::Swap(NormalizedBBox* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NormalizedBBox::InternalSwap(NormalizedBBox* other) {
  using std::swap;
  swap(xmin_, other->xmin_);
  swap(ymin_, other->ymin_);
  swap(xmax_, other->xmax_);
  swap(ymax_, other->ymax_);
  swap(label_, other->label_);
  swap(difficult_, other->difficult_);
  swap(score_, other->score_);
  swap(size_, other->size_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NormalizedBBox::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ROIPoolingParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ROIPoolingParameter::kPooledHFieldNumber;
const int ROIPoolingParameter::kPooledWFieldNumber;
const int ROIPoolingParameter::kSpatialScaleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ROIPoolingParameter::ROIPoolingParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsROIPoolingParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ROIPoolingParameter)
}
ROIPoolingParameter::ROIPoolingParameter(const ROIPoolingParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&pooled_h_, &from.pooled_h_,
    static_cast<size_t>(reinterpret_cast<char*>(&spatial_scale_) -
    reinterpret_cast<char*>(&pooled_h_)) + sizeof(spatial_scale_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ROIPoolingParameter)
}

void ROIPoolingParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&pooled_h_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&pooled_w_) -
      reinterpret_cast<char*>(&pooled_h_)) + sizeof(pooled_w_));
  spatial_scale_ = 1;
}

ROIPoolingParameter::~ROIPoolingParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ROIPoolingParameter)
  SharedDtor();
}

void ROIPoolingParameter::SharedDtor() {
}

void ROIPoolingParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ROIPoolingParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ROIPoolingParameter& ROIPoolingParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsROIPoolingParameter();
  return *internal_default_instance();
}

ROIPoolingParameter* ROIPoolingParameter::New(::google::protobuf::Arena* arena) const {
  ROIPoolingParameter* n = new ROIPoolingParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ROIPoolingParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ROIPoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ::memset(&pooled_h_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&pooled_w_) -
        reinterpret_cast<char*>(&pooled_h_)) + sizeof(pooled_w_));
    spatial_scale_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ROIPoolingParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ROIPoolingParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 pooled_h = 1 [default = 0];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_pooled_h();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pooled_h_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pooled_w = 2 [default = 0];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_pooled_w();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pooled_w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float spatial_scale = 3 [default = 1];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) {
          set_has_spatial_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &spatial_scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ROIPoolingParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ROIPoolingParameter)
  return false;
#undef DO_
}

void ROIPoolingParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ROIPoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 pooled_h = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->pooled_h(), output);
  }

  // optional uint32 pooled_w = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->pooled_w(), output);
  }

  // optional float spatial_scale = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->spatial_scale(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ROIPoolingParameter)
}

::google::protobuf::uint8* ROIPoolingParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ROIPoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 pooled_h = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->pooled_h(), target);
  }

  // optional uint32 pooled_w = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->pooled_w(), target);
  }

  // optional float spatial_scale = 3 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->spatial_scale(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ROIPoolingParameter)
  return target;
}

size_t ROIPoolingParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ROIPoolingParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional uint32 pooled_h = 1 [default = 0];
    if (has_pooled_h()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pooled_h());
    }

    // optional uint32 pooled_w = 2 [default = 0];
    if (has_pooled_w()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pooled_w());
    }

    // optional float spatial_scale = 3 [default = 1];
    if (has_spatial_scale()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ROIPoolingParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ROIPoolingParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ROIPoolingParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ROIPoolingParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ROIPoolingParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ROIPoolingParameter)
    MergeFrom(*source);
  }
}

void ROIPoolingParameter::MergeFrom(const ROIPoolingParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ROIPoolingParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      pooled_h_ = from.pooled_h_;
    }
    if (cached_has_bits & 0x00000002u) {
      pooled_w_ = from.pooled_w_;
    }
    if (cached_has_bits & 0x00000004u) {
      spatial_scale_ = from.spatial_scale_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ROIPoolingParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ROIPoolingParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ROIPoolingParameter::CopyFrom(const ROIPoolingParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ROIPoolingParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ROIPoolingParameter::IsInitialized() const {
  return true;
}

void ROIPoolingParameter::Swap(ROIPoolingParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ROIPoolingParameter::InternalSwap(ROIPoolingParameter* other) {
  using std::swap;
  swap(pooled_h_, other->pooled_h_);
  swap(pooled_w_, other->pooled_w_);
  swap(spatial_scale_, other->spatial_scale_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ROIPoolingParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void ProposalParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ProposalParameter::kFeatStrideFieldNumber;
const int ProposalParameter::kBaseSizeFieldNumber;
const int ProposalParameter::kMinSizeFieldNumber;
const int ProposalParameter::kRatioFieldNumber;
const int ProposalParameter::kScaleFieldNumber;
const int ProposalParameter::kPreNmsTopnFieldNumber;
const int ProposalParameter::kPostNmsTopnFieldNumber;
const int ProposalParameter::kNmsThreshFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ProposalParameter::ProposalParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsProposalParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.ProposalParameter)
}
ProposalParameter::ProposalParameter(const ProposalParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      ratio_(from.ratio_),
      scale_(from.scale_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&feat_stride_, &from.feat_stride_,
    static_cast<size_t>(reinterpret_cast<char*>(&nms_thresh_) -
    reinterpret_cast<char*>(&feat_stride_)) + sizeof(nms_thresh_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.ProposalParameter)
}

void ProposalParameter::SharedCtor() {
  _cached_size_ = 0;
  feat_stride_ = 16u;
  base_size_ = 16u;
  min_size_ = 16u;
  pre_nms_topn_ = 6000u;
  post_nms_topn_ = 300u;
  nms_thresh_ = 0.7f;
}

ProposalParameter::~ProposalParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.ProposalParameter)
  SharedDtor();
}

void ProposalParameter::SharedDtor() {
}

void ProposalParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProposalParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const ProposalParameter& ProposalParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsProposalParameter();
  return *internal_default_instance();
}

ProposalParameter* ProposalParameter::New(::google::protobuf::Arena* arena) const {
  ProposalParameter* n = new ProposalParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ProposalParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.ProposalParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ratio_.Clear();
  scale_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 63u) {
    feat_stride_ = 16u;
    base_size_ = 16u;
    min_size_ = 16u;
    pre_nms_topn_ = 6000u;
    post_nms_topn_ = 300u;
    nms_thresh_ = 0.7f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ProposalParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.ProposalParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 feat_stride = 1 [default = 16];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_feat_stride();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &feat_stride_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 base_size = 2 [default = 16];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_base_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &base_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 min_size = 3 [default = 16];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_min_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &min_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float ratio = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 37u, input, this->mutable_ratio())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_ratio())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float scale = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(45u /* 45 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 45u, input, this->mutable_scale())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_scale())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 pre_nms_topn = 6 [default = 6000];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_pre_nms_topn();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &pre_nms_topn_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 post_nms_topn = 7 [default = 300];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_post_nms_topn();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &post_nms_topn_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float nms_thresh = 8 [default = 0.7];
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(69u /* 69 & 0xFF */)) {
          set_has_nms_thresh();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &nms_thresh_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.ProposalParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.ProposalParameter)
  return false;
#undef DO_
}

void ProposalParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.ProposalParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 feat_stride = 1 [default = 16];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->feat_stride(), output);
  }

  // optional uint32 base_size = 2 [default = 16];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->base_size(), output);
  }

  // optional uint32 min_size = 3 [default = 16];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->min_size(), output);
  }

  // repeated float ratio = 4;
  for (int i = 0, n = this->ratio_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      4, this->ratio(i), output);
  }

  // repeated float scale = 5;
  for (int i = 0, n = this->scale_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      5, this->scale(i), output);
  }

  // optional uint32 pre_nms_topn = 6 [default = 6000];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->pre_nms_topn(), output);
  }

  // optional uint32 post_nms_topn = 7 [default = 300];
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->post_nms_topn(), output);
  }

  // optional float nms_thresh = 8 [default = 0.7];
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->nms_thresh(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.ProposalParameter)
}

::google::protobuf::uint8* ProposalParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.ProposalParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 feat_stride = 1 [default = 16];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->feat_stride(), target);
  }

  // optional uint32 base_size = 2 [default = 16];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->base_size(), target);
  }

  // optional uint32 min_size = 3 [default = 16];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->min_size(), target);
  }

  // repeated float ratio = 4;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(4, this->ratio_, target);

  // repeated float scale = 5;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteFloatToArray(5, this->scale_, target);

  // optional uint32 pre_nms_topn = 6 [default = 6000];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->pre_nms_topn(), target);
  }

  // optional uint32 post_nms_topn = 7 [default = 300];
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->post_nms_topn(), target);
  }

  // optional float nms_thresh = 8 [default = 0.7];
  if (cached_has_bits & 0x00000020u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->nms_thresh(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.ProposalParameter)
  return target;
}

size_t ProposalParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.ProposalParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated float ratio = 4;
  {
    unsigned int count = static_cast<unsigned int>(this->ratio_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->ratio_size());
    total_size += data_size;
  }

  // repeated float scale = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->scale_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->scale_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 63u) {
    // optional uint32 feat_stride = 1 [default = 16];
    if (has_feat_stride()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->feat_stride());
    }

    // optional uint32 base_size = 2 [default = 16];
    if (has_base_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->base_size());
    }

    // optional uint32 min_size = 3 [default = 16];
    if (has_min_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->min_size());
    }

    // optional uint32 pre_nms_topn = 6 [default = 6000];
    if (has_pre_nms_topn()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->pre_nms_topn());
    }

    // optional uint32 post_nms_topn = 7 [default = 300];
    if (has_post_nms_topn()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->post_nms_topn());
    }

    // optional float nms_thresh = 8 [default = 0.7];
    if (has_nms_thresh()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ProposalParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.ProposalParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const ProposalParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ProposalParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.ProposalParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.ProposalParameter)
    MergeFrom(*source);
  }
}

void ProposalParameter::MergeFrom(const ProposalParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.ProposalParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  ratio_.MergeFrom(from.ratio_);
  scale_.MergeFrom(from.scale_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      feat_stride_ = from.feat_stride_;
    }
    if (cached_has_bits & 0x00000002u) {
      base_size_ = from.base_size_;
    }
    if (cached_has_bits & 0x00000004u) {
      min_size_ = from.min_size_;
    }
    if (cached_has_bits & 0x00000008u) {
      pre_nms_topn_ = from.pre_nms_topn_;
    }
    if (cached_has_bits & 0x00000010u) {
      post_nms_topn_ = from.post_nms_topn_;
    }
    if (cached_has_bits & 0x00000020u) {
      nms_thresh_ = from.nms_thresh_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ProposalParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.ProposalParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ProposalParameter::CopyFrom(const ProposalParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.ProposalParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ProposalParameter::IsInitialized() const {
  return true;
}

void ProposalParameter::Swap(ProposalParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ProposalParameter::InternalSwap(ProposalParameter* other) {
  using std::swap;
  ratio_.InternalSwap(&other->ratio_);
  scale_.InternalSwap(&other->scale_);
  swap(feat_stride_, other->feat_stride_);
  swap(base_size_, other->base_size_);
  swap(min_size_, other->min_size_);
  swap(pre_nms_topn_, other->pre_nms_topn_);
  swap(post_nms_topn_, other->post_nms_topn_);
  swap(nms_thresh_, other->nms_thresh_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ProposalParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void PSROIPoolingParameter::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PSROIPoolingParameter::kSpatialScaleFieldNumber;
const int PSROIPoolingParameter::kOutputDimFieldNumber;
const int PSROIPoolingParameter::kGroupSizeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PSROIPoolingParameter::PSROIPoolingParameter()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPSROIPoolingParameter();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:opencv_caffe.PSROIPoolingParameter)
}
PSROIPoolingParameter::PSROIPoolingParameter(const PSROIPoolingParameter& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&spatial_scale_, &from.spatial_scale_,
    static_cast<size_t>(reinterpret_cast<char*>(&group_size_) -
    reinterpret_cast<char*>(&spatial_scale_)) + sizeof(group_size_));
  // @@protoc_insertion_point(copy_constructor:opencv_caffe.PSROIPoolingParameter)
}

void PSROIPoolingParameter::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&spatial_scale_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&group_size_) -
      reinterpret_cast<char*>(&spatial_scale_)) + sizeof(group_size_));
}

PSROIPoolingParameter::~PSROIPoolingParameter() {
  // @@protoc_insertion_point(destructor:opencv_caffe.PSROIPoolingParameter)
  SharedDtor();
}

void PSROIPoolingParameter::SharedDtor() {
}

void PSROIPoolingParameter::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* PSROIPoolingParameter::descriptor() {
  ::protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const PSROIPoolingParameter& PSROIPoolingParameter::default_instance() {
  ::protobuf_opencv_2dcaffe_2eproto::InitDefaultsPSROIPoolingParameter();
  return *internal_default_instance();
}

PSROIPoolingParameter* PSROIPoolingParameter::New(::google::protobuf::Arena* arena) const {
  PSROIPoolingParameter* n = new PSROIPoolingParameter;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PSROIPoolingParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:opencv_caffe.PSROIPoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    ::memset(&spatial_scale_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&group_size_) -
        reinterpret_cast<char*>(&spatial_scale_)) + sizeof(group_size_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PSROIPoolingParameter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:opencv_caffe.PSROIPoolingParameter)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required float spatial_scale = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
          set_has_spatial_scale();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &spatial_scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required int32 output_dim = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_output_dim();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &output_dim_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required int32 group_size = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_group_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &group_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:opencv_caffe.PSROIPoolingParameter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:opencv_caffe.PSROIPoolingParameter)
  return false;
#undef DO_
}

void PSROIPoolingParameter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:opencv_caffe.PSROIPoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required float spatial_scale = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->spatial_scale(), output);
  }

  // required int32 output_dim = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->output_dim(), output);
  }

  // required int32 group_size = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->group_size(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:opencv_caffe.PSROIPoolingParameter)
}

::google::protobuf::uint8* PSROIPoolingParameter::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:opencv_caffe.PSROIPoolingParameter)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required float spatial_scale = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->spatial_scale(), target);
  }

  // required int32 output_dim = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->output_dim(), target);
  }

  // required int32 group_size = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->group_size(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:opencv_caffe.PSROIPoolingParameter)
  return target;
}

size_t PSROIPoolingParameter::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:opencv_caffe.PSROIPoolingParameter)
  size_t total_size = 0;

  if (has_spatial_scale()) {
    // required float spatial_scale = 1;
    total_size += 1 + 4;
  }

  if (has_output_dim()) {
    // required int32 output_dim = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->output_dim());
  }

  if (has_group_size()) {
    // required int32 group_size = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->group_size());
  }

  return total_size;
}
size_t PSROIPoolingParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:opencv_caffe.PSROIPoolingParameter)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required float spatial_scale = 1;
    total_size += 1 + 4;

    // required int32 output_dim = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->output_dim());

    // required int32 group_size = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->group_size());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PSROIPoolingParameter::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:opencv_caffe.PSROIPoolingParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const PSROIPoolingParameter* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const PSROIPoolingParameter>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_caffe.PSROIPoolingParameter)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_caffe.PSROIPoolingParameter)
    MergeFrom(*source);
  }
}

void PSROIPoolingParameter::MergeFrom(const PSROIPoolingParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_caffe.PSROIPoolingParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      spatial_scale_ = from.spatial_scale_;
    }
    if (cached_has_bits & 0x00000002u) {
      output_dim_ = from.output_dim_;
    }
    if (cached_has_bits & 0x00000004u) {
      group_size_ = from.group_size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void PSROIPoolingParameter::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:opencv_caffe.PSROIPoolingParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PSROIPoolingParameter::CopyFrom(const PSROIPoolingParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_caffe.PSROIPoolingParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PSROIPoolingParameter::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
  return true;
}

void PSROIPoolingParameter::Swap(PSROIPoolingParameter* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PSROIPoolingParameter::InternalSwap(PSROIPoolingParameter* other) {
  using std::swap;
  swap(spatial_scale_, other->spatial_scale_);
  swap(output_dim_, other->output_dim_);
  swap(group_size_, other->group_size_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata PSROIPoolingParameter::GetMetadata() const {
  protobuf_opencv_2dcaffe_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_opencv_2dcaffe_2eproto::file_level_metadata[kIndexInFileMessages];
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace opencv_caffe

// @@protoc_insertion_point(global_scope)