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

#ifndef PROTOBUF_caffe_2eproto__INCLUDED
#define PROTOBUF_caffe_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace caffe {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_caffe_2eproto();
void protobuf_AssignDesc_caffe_2eproto();
void protobuf_ShutdownFile_caffe_2eproto();

class BlobProto;
class BlobProtoVector;
class Datum;
class FillerParameter;
class NetParameter;
class SolverParameter;
class SolverState;
class NetState;
class NetStateRule;
class LayerParameter;
class TransformationParameter;
class LossParameter;
class AccuracyParameter;
class ArgMaxParameter;
class ConcatParameter;
class ContrastiveLossParameter;
class ConvolutionParameter;
class MultiStageMeanfieldParameter;
class DataParameter;
class DropoutParameter;
class DummyDataParameter;
class EltwiseParameter;
class ExpParameter;
class HDF5DataParameter;
class HDF5OutputParameter;
class HingeLossParameter;
class ImageDataParameter;
class InfogainLossParameter;
class InnerProductParameter;
class LRNParameter;
class MemoryDataParameter;
class MVNParameter;
class PoolingParameter;
class PowerParameter;
class ReLUParameter;
class SigmoidParameter;
class SliceParameter;
class SoftmaxParameter;
class TanHParameter;
class ThresholdParameter;
class WindowDataParameter;
class V0LayerParameter;

enum SolverParameter_SolverMode {
  SolverParameter_SolverMode_CPU = 0,
  SolverParameter_SolverMode_GPU = 1
};
bool SolverParameter_SolverMode_IsValid(int value);
const SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MIN = SolverParameter_SolverMode_CPU;
const SolverParameter_SolverMode SolverParameter_SolverMode_SolverMode_MAX = SolverParameter_SolverMode_GPU;
const int SolverParameter_SolverMode_SolverMode_ARRAYSIZE = SolverParameter_SolverMode_SolverMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* SolverParameter_SolverMode_descriptor();
inline const ::std::string& SolverParameter_SolverMode_Name(SolverParameter_SolverMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    SolverParameter_SolverMode_descriptor(), value);
}
inline bool SolverParameter_SolverMode_Parse(
    const ::std::string& name, SolverParameter_SolverMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SolverParameter_SolverMode>(
    SolverParameter_SolverMode_descriptor(), name, value);
}
enum SolverParameter_SolverType {
  SolverParameter_SolverType_SGD = 0,
  SolverParameter_SolverType_NESTEROV = 1,
  SolverParameter_SolverType_ADAGRAD = 2
};
bool SolverParameter_SolverType_IsValid(int value);
const SolverParameter_SolverType SolverParameter_SolverType_SolverType_MIN = SolverParameter_SolverType_SGD;
const SolverParameter_SolverType SolverParameter_SolverType_SolverType_MAX = SolverParameter_SolverType_ADAGRAD;
const int SolverParameter_SolverType_SolverType_ARRAYSIZE = SolverParameter_SolverType_SolverType_MAX + 1;

const ::google::protobuf::EnumDescriptor* SolverParameter_SolverType_descriptor();
inline const ::std::string& SolverParameter_SolverType_Name(SolverParameter_SolverType value) {
  return ::google::protobuf::internal::NameOfEnum(
    SolverParameter_SolverType_descriptor(), value);
}
inline bool SolverParameter_SolverType_Parse(
    const ::std::string& name, SolverParameter_SolverType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SolverParameter_SolverType>(
    SolverParameter_SolverType_descriptor(), name, value);
}
enum LayerParameter_LayerType {
  LayerParameter_LayerType_NONE = 0,
  LayerParameter_LayerType_ABSVAL = 35,
  LayerParameter_LayerType_ACCURACY = 1,
  LayerParameter_LayerType_ARGMAX = 30,
  LayerParameter_LayerType_BNLL = 2,
  LayerParameter_LayerType_CONCAT = 3,
  LayerParameter_LayerType_CONTRASTIVE_LOSS = 37,
  LayerParameter_LayerType_CONVOLUTION = 4,
  LayerParameter_LayerType_CROP = 40,
  LayerParameter_LayerType_DATA = 5,
  LayerParameter_LayerType_DECONVOLUTION = 39,
  LayerParameter_LayerType_DROPOUT = 6,
  LayerParameter_LayerType_DUMMY_DATA = 32,
  LayerParameter_LayerType_EUCLIDEAN_LOSS = 7,
  LayerParameter_LayerType_ELTWISE = 25,
  LayerParameter_LayerType_EXP = 38,
  LayerParameter_LayerType_FLATTEN = 8,
  LayerParameter_LayerType_HDF5_DATA = 9,
  LayerParameter_LayerType_HDF5_OUTPUT = 10,
  LayerParameter_LayerType_HINGE_LOSS = 28,
  LayerParameter_LayerType_IM2COL = 11,
  LayerParameter_LayerType_IMAGE_DATA = 12,
  LayerParameter_LayerType_INFOGAIN_LOSS = 13,
  LayerParameter_LayerType_INNER_PRODUCT = 14,
  LayerParameter_LayerType_LRN = 15,
  LayerParameter_LayerType_MEMORY_DATA = 29,
  LayerParameter_LayerType_MULTI_STAGE_MEANFIELD = 42,
  LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS = 16,
  LayerParameter_LayerType_MVN = 34,
  LayerParameter_LayerType_POOLING = 17,
  LayerParameter_LayerType_POWER = 26,
  LayerParameter_LayerType_RELU = 18,
  LayerParameter_LayerType_SIGMOID = 19,
  LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS = 27,
  LayerParameter_LayerType_SILENCE = 36,
  LayerParameter_LayerType_SIMPLE_FAST_MEANFIELD = 41,
  LayerParameter_LayerType_SOFTMAX = 20,
  LayerParameter_LayerType_SOFTMAX_LOSS = 21,
  LayerParameter_LayerType_SPLIT = 22,
  LayerParameter_LayerType_SLICE = 33,
  LayerParameter_LayerType_TANH = 23,
  LayerParameter_LayerType_WINDOW_DATA = 24,
  LayerParameter_LayerType_THRESHOLD = 31
};
bool LayerParameter_LayerType_IsValid(int value);
const LayerParameter_LayerType LayerParameter_LayerType_LayerType_MIN = LayerParameter_LayerType_NONE;
const LayerParameter_LayerType LayerParameter_LayerType_LayerType_MAX = LayerParameter_LayerType_MULTI_STAGE_MEANFIELD;
const int LayerParameter_LayerType_LayerType_ARRAYSIZE = LayerParameter_LayerType_LayerType_MAX + 1;

const ::google::protobuf::EnumDescriptor* LayerParameter_LayerType_descriptor();
inline const ::std::string& LayerParameter_LayerType_Name(LayerParameter_LayerType value) {
  return ::google::protobuf::internal::NameOfEnum(
    LayerParameter_LayerType_descriptor(), value);
}
inline bool LayerParameter_LayerType_Parse(
    const ::std::string& name, LayerParameter_LayerType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LayerParameter_LayerType>(
    LayerParameter_LayerType_descriptor(), name, value);
}
enum LayerParameter_DimCheckMode {
  LayerParameter_DimCheckMode_STRICT = 0,
  LayerParameter_DimCheckMode_PERMISSIVE = 1
};
bool LayerParameter_DimCheckMode_IsValid(int value);
const LayerParameter_DimCheckMode LayerParameter_DimCheckMode_DimCheckMode_MIN = LayerParameter_DimCheckMode_STRICT;
const LayerParameter_DimCheckMode LayerParameter_DimCheckMode_DimCheckMode_MAX = LayerParameter_DimCheckMode_PERMISSIVE;
const int LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE = LayerParameter_DimCheckMode_DimCheckMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* LayerParameter_DimCheckMode_descriptor();
inline const ::std::string& LayerParameter_DimCheckMode_Name(LayerParameter_DimCheckMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    LayerParameter_DimCheckMode_descriptor(), value);
}
inline bool LayerParameter_DimCheckMode_Parse(
    const ::std::string& name, LayerParameter_DimCheckMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LayerParameter_DimCheckMode>(
    LayerParameter_DimCheckMode_descriptor(), name, value);
}
enum ConvolutionParameter_Engine {
  ConvolutionParameter_Engine_DEFAULT = 0,
  ConvolutionParameter_Engine_CAFFE = 1,
  ConvolutionParameter_Engine_CUDNN = 2
};
bool ConvolutionParameter_Engine_IsValid(int value);
const ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MIN = ConvolutionParameter_Engine_DEFAULT;
const ConvolutionParameter_Engine ConvolutionParameter_Engine_Engine_MAX = ConvolutionParameter_Engine_CUDNN;
const int ConvolutionParameter_Engine_Engine_ARRAYSIZE = ConvolutionParameter_Engine_Engine_MAX + 1;

const ::google::protobuf::EnumDescriptor* ConvolutionParameter_Engine_descriptor();
inline const ::std::string& ConvolutionParameter_Engine_Name(ConvolutionParameter_Engine value) {
  return ::google::protobuf::internal::NameOfEnum(
    ConvolutionParameter_Engine_descriptor(), value);
}
inline bool ConvolutionParameter_Engine_Parse(
    const ::std::string& name, ConvolutionParameter_Engine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ConvolutionParameter_Engine>(
    ConvolutionParameter_Engine_descriptor(), name, value);
}
enum MultiStageMeanfieldParameter_Mode {
  MultiStageMeanfieldParameter_Mode_POTTS = 0
};
bool MultiStageMeanfieldParameter_Mode_IsValid(int value);
const MultiStageMeanfieldParameter_Mode MultiStageMeanfieldParameter_Mode_Mode_MIN = MultiStageMeanfieldParameter_Mode_POTTS;
const MultiStageMeanfieldParameter_Mode MultiStageMeanfieldParameter_Mode_Mode_MAX = MultiStageMeanfieldParameter_Mode_POTTS;
const int MultiStageMeanfieldParameter_Mode_Mode_ARRAYSIZE = MultiStageMeanfieldParameter_Mode_Mode_MAX + 1;

const ::google::protobuf::EnumDescriptor* MultiStageMeanfieldParameter_Mode_descriptor();
inline const ::std::string& MultiStageMeanfieldParameter_Mode_Name(MultiStageMeanfieldParameter_Mode value) {
  return ::google::protobuf::internal::NameOfEnum(
    MultiStageMeanfieldParameter_Mode_descriptor(), value);
}
inline bool MultiStageMeanfieldParameter_Mode_Parse(
    const ::std::string& name, MultiStageMeanfieldParameter_Mode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<MultiStageMeanfieldParameter_Mode>(
    MultiStageMeanfieldParameter_Mode_descriptor(), name, value);
}
enum DataParameter_DB {
  DataParameter_DB_LEVELDB = 0,
  DataParameter_DB_LMDB = 1
};
bool DataParameter_DB_IsValid(int value);
const DataParameter_DB DataParameter_DB_DB_MIN = DataParameter_DB_LEVELDB;
const DataParameter_DB DataParameter_DB_DB_MAX = DataParameter_DB_LMDB;
const int DataParameter_DB_DB_ARRAYSIZE = DataParameter_DB_DB_MAX + 1;

const ::google::protobuf::EnumDescriptor* DataParameter_DB_descriptor();
inline const ::std::string& DataParameter_DB_Name(DataParameter_DB value) {
  return ::google::protobuf::internal::NameOfEnum(
    DataParameter_DB_descriptor(), value);
}
inline bool DataParameter_DB_Parse(
    const ::std::string& name, DataParameter_DB* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DataParameter_DB>(
    DataParameter_DB_descriptor(), name, value);
}
enum EltwiseParameter_EltwiseOp {
  EltwiseParameter_EltwiseOp_PROD = 0,
  EltwiseParameter_EltwiseOp_SUM = 1,
  EltwiseParameter_EltwiseOp_MAX = 2
};
bool EltwiseParameter_EltwiseOp_IsValid(int value);
const EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MIN = EltwiseParameter_EltwiseOp_PROD;
const EltwiseParameter_EltwiseOp EltwiseParameter_EltwiseOp_EltwiseOp_MAX = EltwiseParameter_EltwiseOp_MAX;
const int EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE = EltwiseParameter_EltwiseOp_EltwiseOp_MAX + 1;

const ::google::protobuf::EnumDescriptor* EltwiseParameter_EltwiseOp_descriptor();
inline const ::std::string& EltwiseParameter_EltwiseOp_Name(EltwiseParameter_EltwiseOp value) {
  return ::google::protobuf::internal::NameOfEnum(
    EltwiseParameter_EltwiseOp_descriptor(), value);
}
inline bool EltwiseParameter_EltwiseOp_Parse(
    const ::std::string& name, EltwiseParameter_EltwiseOp* value) {
  return ::google::protobuf::internal::ParseNamedEnum<EltwiseParameter_EltwiseOp>(
    EltwiseParameter_EltwiseOp_descriptor(), name, value);
}
enum HingeLossParameter_Norm {
  HingeLossParameter_Norm_L1 = 1,
  HingeLossParameter_Norm_L2 = 2
};
bool HingeLossParameter_Norm_IsValid(int value);
const HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MIN = HingeLossParameter_Norm_L1;
const HingeLossParameter_Norm HingeLossParameter_Norm_Norm_MAX = HingeLossParameter_Norm_L2;
const int HingeLossParameter_Norm_Norm_ARRAYSIZE = HingeLossParameter_Norm_Norm_MAX + 1;

const ::google::protobuf::EnumDescriptor* HingeLossParameter_Norm_descriptor();
inline const ::std::string& HingeLossParameter_Norm_Name(HingeLossParameter_Norm value) {
  return ::google::protobuf::internal::NameOfEnum(
    HingeLossParameter_Norm_descriptor(), value);
}
inline bool HingeLossParameter_Norm_Parse(
    const ::std::string& name, HingeLossParameter_Norm* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HingeLossParameter_Norm>(
    HingeLossParameter_Norm_descriptor(), name, value);
}
enum LRNParameter_NormRegion {
  LRNParameter_NormRegion_ACROSS_CHANNELS = 0,
  LRNParameter_NormRegion_WITHIN_CHANNEL = 1
};
bool LRNParameter_NormRegion_IsValid(int value);
const LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MIN = LRNParameter_NormRegion_ACROSS_CHANNELS;
const LRNParameter_NormRegion LRNParameter_NormRegion_NormRegion_MAX = LRNParameter_NormRegion_WITHIN_CHANNEL;
const int LRNParameter_NormRegion_NormRegion_ARRAYSIZE = LRNParameter_NormRegion_NormRegion_MAX + 1;

const ::google::protobuf::EnumDescriptor* LRNParameter_NormRegion_descriptor();
inline const ::std::string& LRNParameter_NormRegion_Name(LRNParameter_NormRegion value) {
  return ::google::protobuf::internal::NameOfEnum(
    LRNParameter_NormRegion_descriptor(), value);
}
inline bool LRNParameter_NormRegion_Parse(
    const ::std::string& name, LRNParameter_NormRegion* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LRNParameter_NormRegion>(
    LRNParameter_NormRegion_descriptor(), name, value);
}
enum PoolingParameter_PoolMethod {
  PoolingParameter_PoolMethod_MAX = 0,
  PoolingParameter_PoolMethod_AVE = 1,
  PoolingParameter_PoolMethod_STOCHASTIC = 2
};
bool PoolingParameter_PoolMethod_IsValid(int value);
const PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MIN = PoolingParameter_PoolMethod_MAX;
const PoolingParameter_PoolMethod PoolingParameter_PoolMethod_PoolMethod_MAX = PoolingParameter_PoolMethod_STOCHASTIC;
const int PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE = PoolingParameter_PoolMethod_PoolMethod_MAX + 1;

const ::google::protobuf::EnumDescriptor* PoolingParameter_PoolMethod_descriptor();
inline const ::std::string& PoolingParameter_PoolMethod_Name(PoolingParameter_PoolMethod value) {
  return ::google::protobuf::internal::NameOfEnum(
    PoolingParameter_PoolMethod_descriptor(), value);
}
inline bool PoolingParameter_PoolMethod_Parse(
    const ::std::string& name, PoolingParameter_PoolMethod* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PoolingParameter_PoolMethod>(
    PoolingParameter_PoolMethod_descriptor(), name, value);
}
enum PoolingParameter_Engine {
  PoolingParameter_Engine_DEFAULT = 0,
  PoolingParameter_Engine_CAFFE = 1,
  PoolingParameter_Engine_CUDNN = 2
};
bool PoolingParameter_Engine_IsValid(int value);
const PoolingParameter_Engine PoolingParameter_Engine_Engine_MIN = PoolingParameter_Engine_DEFAULT;
const PoolingParameter_Engine PoolingParameter_Engine_Engine_MAX = PoolingParameter_Engine_CUDNN;
const int PoolingParameter_Engine_Engine_ARRAYSIZE = PoolingParameter_Engine_Engine_MAX + 1;

const ::google::protobuf::EnumDescriptor* PoolingParameter_Engine_descriptor();
inline const ::std::string& PoolingParameter_Engine_Name(PoolingParameter_Engine value) {
  return ::google::protobuf::internal::NameOfEnum(
    PoolingParameter_Engine_descriptor(), value);
}
inline bool PoolingParameter_Engine_Parse(
    const ::std::string& name, PoolingParameter_Engine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<PoolingParameter_Engine>(
    PoolingParameter_Engine_descriptor(), name, value);
}
enum ReLUParameter_Engine {
  ReLUParameter_Engine_DEFAULT = 0,
  ReLUParameter_Engine_CAFFE = 1,
  ReLUParameter_Engine_CUDNN = 2
};
bool ReLUParameter_Engine_IsValid(int value);
const ReLUParameter_Engine ReLUParameter_Engine_Engine_MIN = ReLUParameter_Engine_DEFAULT;
const ReLUParameter_Engine ReLUParameter_Engine_Engine_MAX = ReLUParameter_Engine_CUDNN;
const int ReLUParameter_Engine_Engine_ARRAYSIZE = ReLUParameter_Engine_Engine_MAX + 1;

const ::google::protobuf::EnumDescriptor* ReLUParameter_Engine_descriptor();
inline const ::std::string& ReLUParameter_Engine_Name(ReLUParameter_Engine value) {
  return ::google::protobuf::internal::NameOfEnum(
    ReLUParameter_Engine_descriptor(), value);
}
inline bool ReLUParameter_Engine_Parse(
    const ::std::string& name, ReLUParameter_Engine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ReLUParameter_Engine>(
    ReLUParameter_Engine_descriptor(), name, value);
}
enum SigmoidParameter_Engine {
  SigmoidParameter_Engine_DEFAULT = 0,
  SigmoidParameter_Engine_CAFFE = 1,
  SigmoidParameter_Engine_CUDNN = 2
};
bool SigmoidParameter_Engine_IsValid(int value);
const SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MIN = SigmoidParameter_Engine_DEFAULT;
const SigmoidParameter_Engine SigmoidParameter_Engine_Engine_MAX = SigmoidParameter_Engine_CUDNN;
const int SigmoidParameter_Engine_Engine_ARRAYSIZE = SigmoidParameter_Engine_Engine_MAX + 1;

const ::google::protobuf::EnumDescriptor* SigmoidParameter_Engine_descriptor();
inline const ::std::string& SigmoidParameter_Engine_Name(SigmoidParameter_Engine value) {
  return ::google::protobuf::internal::NameOfEnum(
    SigmoidParameter_Engine_descriptor(), value);
}
inline bool SigmoidParameter_Engine_Parse(
    const ::std::string& name, SigmoidParameter_Engine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SigmoidParameter_Engine>(
    SigmoidParameter_Engine_descriptor(), name, value);
}
enum SoftmaxParameter_Engine {
  SoftmaxParameter_Engine_DEFAULT = 0,
  SoftmaxParameter_Engine_CAFFE = 1,
  SoftmaxParameter_Engine_CUDNN = 2
};
bool SoftmaxParameter_Engine_IsValid(int value);
const SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MIN = SoftmaxParameter_Engine_DEFAULT;
const SoftmaxParameter_Engine SoftmaxParameter_Engine_Engine_MAX = SoftmaxParameter_Engine_CUDNN;
const int SoftmaxParameter_Engine_Engine_ARRAYSIZE = SoftmaxParameter_Engine_Engine_MAX + 1;

const ::google::protobuf::EnumDescriptor* SoftmaxParameter_Engine_descriptor();
inline const ::std::string& SoftmaxParameter_Engine_Name(SoftmaxParameter_Engine value) {
  return ::google::protobuf::internal::NameOfEnum(
    SoftmaxParameter_Engine_descriptor(), value);
}
inline bool SoftmaxParameter_Engine_Parse(
    const ::std::string& name, SoftmaxParameter_Engine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SoftmaxParameter_Engine>(
    SoftmaxParameter_Engine_descriptor(), name, value);
}
enum TanHParameter_Engine {
  TanHParameter_Engine_DEFAULT = 0,
  TanHParameter_Engine_CAFFE = 1,
  TanHParameter_Engine_CUDNN = 2
};
bool TanHParameter_Engine_IsValid(int value);
const TanHParameter_Engine TanHParameter_Engine_Engine_MIN = TanHParameter_Engine_DEFAULT;
const TanHParameter_Engine TanHParameter_Engine_Engine_MAX = TanHParameter_Engine_CUDNN;
const int TanHParameter_Engine_Engine_ARRAYSIZE = TanHParameter_Engine_Engine_MAX + 1;

const ::google::protobuf::EnumDescriptor* TanHParameter_Engine_descriptor();
inline const ::std::string& TanHParameter_Engine_Name(TanHParameter_Engine value) {
  return ::google::protobuf::internal::NameOfEnum(
    TanHParameter_Engine_descriptor(), value);
}
inline bool TanHParameter_Engine_Parse(
    const ::std::string& name, TanHParameter_Engine* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TanHParameter_Engine>(
    TanHParameter_Engine_descriptor(), name, value);
}
enum V0LayerParameter_PoolMethod {
  V0LayerParameter_PoolMethod_MAX = 0,
  V0LayerParameter_PoolMethod_AVE = 1,
  V0LayerParameter_PoolMethod_STOCHASTIC = 2
};
bool V0LayerParameter_PoolMethod_IsValid(int value);
const V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MIN = V0LayerParameter_PoolMethod_MAX;
const V0LayerParameter_PoolMethod V0LayerParameter_PoolMethod_PoolMethod_MAX = V0LayerParameter_PoolMethod_STOCHASTIC;
const int V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE = V0LayerParameter_PoolMethod_PoolMethod_MAX + 1;

const ::google::protobuf::EnumDescriptor* V0LayerParameter_PoolMethod_descriptor();
inline const ::std::string& V0LayerParameter_PoolMethod_Name(V0LayerParameter_PoolMethod value) {
  return ::google::protobuf::internal::NameOfEnum(
    V0LayerParameter_PoolMethod_descriptor(), value);
}
inline bool V0LayerParameter_PoolMethod_Parse(
    const ::std::string& name, V0LayerParameter_PoolMethod* value) {
  return ::google::protobuf::internal::ParseNamedEnum<V0LayerParameter_PoolMethod>(
    V0LayerParameter_PoolMethod_descriptor(), name, value);
}
enum Phase {
  TRAIN = 0,
  TEST = 1
};
bool Phase_IsValid(int value);
const Phase Phase_MIN = TRAIN;
const Phase Phase_MAX = TEST;
const int Phase_ARRAYSIZE = Phase_MAX + 1;

const ::google::protobuf::EnumDescriptor* Phase_descriptor();
inline const ::std::string& Phase_Name(Phase value) {
  return ::google::protobuf::internal::NameOfEnum(
    Phase_descriptor(), value);
}
inline bool Phase_Parse(
    const ::std::string& name, Phase* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Phase>(
    Phase_descriptor(), name, value);
}
// ===================================================================

class BlobProto : public ::google::protobuf::Message {
 public:
  BlobProto();
  virtual ~BlobProto();

  BlobProto(const BlobProto& from);

  inline BlobProto& operator=(const BlobProto& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlobProto& default_instance();

  void Swap(BlobProto* other);

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

  BlobProto* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlobProto& from);
  void MergeFrom(const BlobProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional int32 num = 1 [default = 0];
  inline bool has_num() const;
  inline void clear_num();
  static const int kNumFieldNumber = 1;
  inline ::google::protobuf::int32 num() const;
  inline void set_num(::google::protobuf::int32 value);

  // optional int32 channels = 2 [default = 0];
  inline bool has_channels() const;
  inline void clear_channels();
  static const int kChannelsFieldNumber = 2;
  inline ::google::protobuf::int32 channels() const;
  inline void set_channels(::google::protobuf::int32 value);

  // optional int32 height = 3 [default = 0];
  inline bool has_height() const;
  inline void clear_height();
  static const int kHeightFieldNumber = 3;
  inline ::google::protobuf::int32 height() const;
  inline void set_height(::google::protobuf::int32 value);

  // optional int32 width = 4 [default = 0];
  inline bool has_width() const;
  inline void clear_width();
  static const int kWidthFieldNumber = 4;
  inline ::google::protobuf::int32 width() const;
  inline void set_width(::google::protobuf::int32 value);

  // repeated float data = 5 [packed = true];
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 5;
  inline float data(int index) const;
  inline void set_data(int index, float value);
  inline void add_data(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      data() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_data();

  // repeated float diff = 6 [packed = true];
  inline int diff_size() const;
  inline void clear_diff();
  static const int kDiffFieldNumber = 6;
  inline float diff(int index) const;
  inline void set_diff(int index, float value);
  inline void add_diff(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      diff() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_diff();

  // @@protoc_insertion_point(class_scope:caffe.BlobProto)
 private:
  inline void set_has_num();
  inline void clear_has_num();
  inline void set_has_channels();
  inline void clear_has_channels();
  inline void set_has_height();
  inline void clear_has_height();
  inline void set_has_width();
  inline void clear_has_width();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 num_;
  ::google::protobuf::int32 channels_;
  ::google::protobuf::int32 height_;
  ::google::protobuf::int32 width_;
  ::google::protobuf::RepeatedField< float > data_;
  mutable int _data_cached_byte_size_;
  ::google::protobuf::RepeatedField< float > diff_;
  mutable int _diff_cached_byte_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static BlobProto* default_instance_;
};
// -------------------------------------------------------------------

class BlobProtoVector : public ::google::protobuf::Message {
 public:
  BlobProtoVector();
  virtual ~BlobProtoVector();

  BlobProtoVector(const BlobProtoVector& from);

  inline BlobProtoVector& operator=(const BlobProtoVector& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BlobProtoVector& default_instance();

  void Swap(BlobProtoVector* other);

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

  BlobProtoVector* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BlobProtoVector& from);
  void MergeFrom(const BlobProtoVector& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .caffe.BlobProto blobs = 1;
  inline int blobs_size() const;
  inline void clear_blobs();
  static const int kBlobsFieldNumber = 1;
  inline const ::caffe::BlobProto& blobs(int index) const;
  inline ::caffe::BlobProto* mutable_blobs(int index);
  inline ::caffe::BlobProto* add_blobs();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
      blobs() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
      mutable_blobs();

  // @@protoc_insertion_point(class_scope:caffe.BlobProtoVector)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static BlobProtoVector* default_instance_;
};
// -------------------------------------------------------------------

class Datum : public ::google::protobuf::Message {
 public:
  Datum();
  virtual ~Datum();

  Datum(const Datum& from);

  inline Datum& operator=(const Datum& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Datum& default_instance();

  void Swap(Datum* other);

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

  Datum* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Datum& from);
  void MergeFrom(const Datum& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional int32 channels = 1;
  inline bool has_channels() const;
  inline void clear_channels();
  static const int kChannelsFieldNumber = 1;
  inline ::google::protobuf::int32 channels() const;
  inline void set_channels(::google::protobuf::int32 value);

  // optional int32 height = 2;
  inline bool has_height() const;
  inline void clear_height();
  static const int kHeightFieldNumber = 2;
  inline ::google::protobuf::int32 height() const;
  inline void set_height(::google::protobuf::int32 value);

  // optional int32 width = 3;
  inline bool has_width() const;
  inline void clear_width();
  static const int kWidthFieldNumber = 3;
  inline ::google::protobuf::int32 width() const;
  inline void set_width(::google::protobuf::int32 value);

  // optional bytes data = 4;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 4;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional int32 label = 5;
  inline bool has_label() const;
  inline void clear_label();
  static const int kLabelFieldNumber = 5;
  inline ::google::protobuf::int32 label() const;
  inline void set_label(::google::protobuf::int32 value);

  // repeated float float_data = 6;
  inline int float_data_size() const;
  inline void clear_float_data();
  static const int kFloatDataFieldNumber = 6;
  inline float float_data(int index) const;
  inline void set_float_data(int index, float value);
  inline void add_float_data(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      float_data() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_float_data();

  // optional bool encoded = 7 [default = false];
  inline bool has_encoded() const;
  inline void clear_encoded();
  static const int kEncodedFieldNumber = 7;
  inline bool encoded() const;
  inline void set_encoded(bool value);

  // @@protoc_insertion_point(class_scope:caffe.Datum)
 private:
  inline void set_has_channels();
  inline void clear_has_channels();
  inline void set_has_height();
  inline void clear_has_height();
  inline void set_has_width();
  inline void clear_has_width();
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_label();
  inline void clear_has_label();
  inline void set_has_encoded();
  inline void clear_has_encoded();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 channels_;
  ::google::protobuf::int32 height_;
  ::std::string* data_;
  ::google::protobuf::int32 width_;
  ::google::protobuf::int32 label_;
  ::google::protobuf::RepeatedField< float > float_data_;
  bool encoded_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static Datum* default_instance_;
};
// -------------------------------------------------------------------

class FillerParameter : public ::google::protobuf::Message {
 public:
  FillerParameter();
  virtual ~FillerParameter();

  FillerParameter(const FillerParameter& from);

  inline FillerParameter& operator=(const FillerParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FillerParameter& default_instance();

  void Swap(FillerParameter* other);

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

  FillerParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FillerParameter& from);
  void MergeFrom(const FillerParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string type = 1 [default = "constant"];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline const ::std::string& type() const;
  inline void set_type(const ::std::string& value);
  inline void set_type(const char* value);
  inline void set_type(const char* value, size_t size);
  inline ::std::string* mutable_type();
  inline ::std::string* release_type();
  inline void set_allocated_type(::std::string* type);

  // optional float value = 2 [default = 0];
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline float value() const;
  inline void set_value(float value);

  // optional float min = 3 [default = 0];
  inline bool has_min() const;
  inline void clear_min();
  static const int kMinFieldNumber = 3;
  inline float min() const;
  inline void set_min(float value);

  // optional float max = 4 [default = 1];
  inline bool has_max() const;
  inline void clear_max();
  static const int kMaxFieldNumber = 4;
  inline float max() const;
  inline void set_max(float value);

  // optional float mean = 5 [default = 0];
  inline bool has_mean() const;
  inline void clear_mean();
  static const int kMeanFieldNumber = 5;
  inline float mean() const;
  inline void set_mean(float value);

  // optional float std = 6 [default = 1];
  inline bool has_std() const;
  inline void clear_std();
  static const int kStdFieldNumber = 6;
  inline float std() const;
  inline void set_std(float value);

  // optional int32 sparse = 7 [default = -1];
  inline bool has_sparse() const;
  inline void clear_sparse();
  static const int kSparseFieldNumber = 7;
  inline ::google::protobuf::int32 sparse() const;
  inline void set_sparse(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:caffe.FillerParameter)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_value();
  inline void clear_has_value();
  inline void set_has_min();
  inline void clear_has_min();
  inline void set_has_max();
  inline void clear_has_max();
  inline void set_has_mean();
  inline void clear_has_mean();
  inline void set_has_std();
  inline void clear_has_std();
  inline void set_has_sparse();
  inline void clear_has_sparse();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* type_;
  static ::std::string* _default_type_;
  float value_;
  float min_;
  float max_;
  float mean_;
  float std_;
  ::google::protobuf::int32 sparse_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static FillerParameter* default_instance_;
};
// -------------------------------------------------------------------

class NetParameter : public ::google::protobuf::Message {
 public:
  NetParameter();
  virtual ~NetParameter();

  NetParameter(const NetParameter& from);

  inline NetParameter& operator=(const NetParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NetParameter& default_instance();

  void Swap(NetParameter* other);

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

  NetParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NetParameter& from);
  void MergeFrom(const NetParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // repeated .caffe.LayerParameter layers = 2;
  inline int layers_size() const;
  inline void clear_layers();
  static const int kLayersFieldNumber = 2;
  inline const ::caffe::LayerParameter& layers(int index) const;
  inline ::caffe::LayerParameter* mutable_layers(int index);
  inline ::caffe::LayerParameter* add_layers();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >&
      layers() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >*
      mutable_layers();

  // repeated string input = 3;
  inline int input_size() const;
  inline void clear_input();
  static const int kInputFieldNumber = 3;
  inline const ::std::string& input(int index) const;
  inline ::std::string* mutable_input(int index);
  inline void set_input(int index, const ::std::string& value);
  inline void set_input(int index, const char* value);
  inline void set_input(int index, const char* value, size_t size);
  inline ::std::string* add_input();
  inline void add_input(const ::std::string& value);
  inline void add_input(const char* value);
  inline void add_input(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();

  // repeated int32 input_dim = 4;
  inline int input_dim_size() const;
  inline void clear_input_dim();
  static const int kInputDimFieldNumber = 4;
  inline ::google::protobuf::int32 input_dim(int index) const;
  inline void set_input_dim(int index, ::google::protobuf::int32 value);
  inline void add_input_dim(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      input_dim() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_input_dim();

  // optional bool force_backward = 5 [default = false];
  inline bool has_force_backward() const;
  inline void clear_force_backward();
  static const int kForceBackwardFieldNumber = 5;
  inline bool force_backward() const;
  inline void set_force_backward(bool value);

  // optional .caffe.NetState state = 6;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 6;
  inline const ::caffe::NetState& state() const;
  inline ::caffe::NetState* mutable_state();
  inline ::caffe::NetState* release_state();
  inline void set_allocated_state(::caffe::NetState* state);

  // @@protoc_insertion_point(class_scope:caffe.NetParameter)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_force_backward();
  inline void clear_has_force_backward();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter > layers_;
  ::google::protobuf::RepeatedPtrField< ::std::string> input_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > input_dim_;
  ::caffe::NetState* state_;
  bool force_backward_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static NetParameter* default_instance_;
};
// -------------------------------------------------------------------

class SolverParameter : public ::google::protobuf::Message {
 public:
  SolverParameter();
  virtual ~SolverParameter();

  SolverParameter(const SolverParameter& from);

  inline SolverParameter& operator=(const SolverParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SolverParameter& default_instance();

  void Swap(SolverParameter* other);

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

  SolverParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SolverParameter& from);
  void MergeFrom(const SolverParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef SolverParameter_SolverMode SolverMode;
  static const SolverMode CPU = SolverParameter_SolverMode_CPU;
  static const SolverMode GPU = SolverParameter_SolverMode_GPU;
  static inline bool SolverMode_IsValid(int value) {
    return SolverParameter_SolverMode_IsValid(value);
  }
  static const SolverMode SolverMode_MIN =
    SolverParameter_SolverMode_SolverMode_MIN;
  static const SolverMode SolverMode_MAX =
    SolverParameter_SolverMode_SolverMode_MAX;
  static const int SolverMode_ARRAYSIZE =
    SolverParameter_SolverMode_SolverMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  SolverMode_descriptor() {
    return SolverParameter_SolverMode_descriptor();
  }
  static inline const ::std::string& SolverMode_Name(SolverMode value) {
    return SolverParameter_SolverMode_Name(value);
  }
  static inline bool SolverMode_Parse(const ::std::string& name,
      SolverMode* value) {
    return SolverParameter_SolverMode_Parse(name, value);
  }

  typedef SolverParameter_SolverType SolverType;
  static const SolverType SGD = SolverParameter_SolverType_SGD;
  static const SolverType NESTEROV = SolverParameter_SolverType_NESTEROV;
  static const SolverType ADAGRAD = SolverParameter_SolverType_ADAGRAD;
  static inline bool SolverType_IsValid(int value) {
    return SolverParameter_SolverType_IsValid(value);
  }
  static const SolverType SolverType_MIN =
    SolverParameter_SolverType_SolverType_MIN;
  static const SolverType SolverType_MAX =
    SolverParameter_SolverType_SolverType_MAX;
  static const int SolverType_ARRAYSIZE =
    SolverParameter_SolverType_SolverType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  SolverType_descriptor() {
    return SolverParameter_SolverType_descriptor();
  }
  static inline const ::std::string& SolverType_Name(SolverType value) {
    return SolverParameter_SolverType_Name(value);
  }
  static inline bool SolverType_Parse(const ::std::string& name,
      SolverType* value) {
    return SolverParameter_SolverType_Parse(name, value);
  }

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

  // optional string net = 24;
  inline bool has_net() const;
  inline void clear_net();
  static const int kNetFieldNumber = 24;
  inline const ::std::string& net() const;
  inline void set_net(const ::std::string& value);
  inline void set_net(const char* value);
  inline void set_net(const char* value, size_t size);
  inline ::std::string* mutable_net();
  inline ::std::string* release_net();
  inline void set_allocated_net(::std::string* net);

  // optional .caffe.NetParameter net_param = 25;
  inline bool has_net_param() const;
  inline void clear_net_param();
  static const int kNetParamFieldNumber = 25;
  inline const ::caffe::NetParameter& net_param() const;
  inline ::caffe::NetParameter* mutable_net_param();
  inline ::caffe::NetParameter* release_net_param();
  inline void set_allocated_net_param(::caffe::NetParameter* net_param);

  // optional string train_net = 1;
  inline bool has_train_net() const;
  inline void clear_train_net();
  static const int kTrainNetFieldNumber = 1;
  inline const ::std::string& train_net() const;
  inline void set_train_net(const ::std::string& value);
  inline void set_train_net(const char* value);
  inline void set_train_net(const char* value, size_t size);
  inline ::std::string* mutable_train_net();
  inline ::std::string* release_train_net();
  inline void set_allocated_train_net(::std::string* train_net);

  // repeated string test_net = 2;
  inline int test_net_size() const;
  inline void clear_test_net();
  static const int kTestNetFieldNumber = 2;
  inline const ::std::string& test_net(int index) const;
  inline ::std::string* mutable_test_net(int index);
  inline void set_test_net(int index, const ::std::string& value);
  inline void set_test_net(int index, const char* value);
  inline void set_test_net(int index, const char* value, size_t size);
  inline ::std::string* add_test_net();
  inline void add_test_net(const ::std::string& value);
  inline void add_test_net(const char* value);
  inline void add_test_net(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& test_net() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_test_net();

  // optional .caffe.NetParameter train_net_param = 21;
  inline bool has_train_net_param() const;
  inline void clear_train_net_param();
  static const int kTrainNetParamFieldNumber = 21;
  inline const ::caffe::NetParameter& train_net_param() const;
  inline ::caffe::NetParameter* mutable_train_net_param();
  inline ::caffe::NetParameter* release_train_net_param();
  inline void set_allocated_train_net_param(::caffe::NetParameter* train_net_param);

  // repeated .caffe.NetParameter test_net_param = 22;
  inline int test_net_param_size() const;
  inline void clear_test_net_param();
  static const int kTestNetParamFieldNumber = 22;
  inline const ::caffe::NetParameter& test_net_param(int index) const;
  inline ::caffe::NetParameter* mutable_test_net_param(int index);
  inline ::caffe::NetParameter* add_test_net_param();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >&
      test_net_param() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >*
      mutable_test_net_param();

  // optional .caffe.NetState train_state = 26;
  inline bool has_train_state() const;
  inline void clear_train_state();
  static const int kTrainStateFieldNumber = 26;
  inline const ::caffe::NetState& train_state() const;
  inline ::caffe::NetState* mutable_train_state();
  inline ::caffe::NetState* release_train_state();
  inline void set_allocated_train_state(::caffe::NetState* train_state);

  // repeated .caffe.NetState test_state = 27;
  inline int test_state_size() const;
  inline void clear_test_state();
  static const int kTestStateFieldNumber = 27;
  inline const ::caffe::NetState& test_state(int index) const;
  inline ::caffe::NetState* mutable_test_state(int index);
  inline ::caffe::NetState* add_test_state();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetState >&
      test_state() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::NetState >*
      mutable_test_state();

  // repeated int32 test_iter = 3;
  inline int test_iter_size() const;
  inline void clear_test_iter();
  static const int kTestIterFieldNumber = 3;
  inline ::google::protobuf::int32 test_iter(int index) const;
  inline void set_test_iter(int index, ::google::protobuf::int32 value);
  inline void add_test_iter(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      test_iter() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_test_iter();

  // optional int32 test_interval = 4 [default = 0];
  inline bool has_test_interval() const;
  inline void clear_test_interval();
  static const int kTestIntervalFieldNumber = 4;
  inline ::google::protobuf::int32 test_interval() const;
  inline void set_test_interval(::google::protobuf::int32 value);

  // optional bool test_compute_loss = 19 [default = false];
  inline bool has_test_compute_loss() const;
  inline void clear_test_compute_loss();
  static const int kTestComputeLossFieldNumber = 19;
  inline bool test_compute_loss() const;
  inline void set_test_compute_loss(bool value);

  // optional bool test_initialization = 32 [default = true];
  inline bool has_test_initialization() const;
  inline void clear_test_initialization();
  static const int kTestInitializationFieldNumber = 32;
  inline bool test_initialization() const;
  inline void set_test_initialization(bool value);

  // optional float base_lr = 5;
  inline bool has_base_lr() const;
  inline void clear_base_lr();
  static const int kBaseLrFieldNumber = 5;
  inline float base_lr() const;
  inline void set_base_lr(float value);

  // optional int32 display = 6;
  inline bool has_display() const;
  inline void clear_display();
  static const int kDisplayFieldNumber = 6;
  inline ::google::protobuf::int32 display() const;
  inline void set_display(::google::protobuf::int32 value);

  // optional int32 average_loss = 33 [default = 1];
  inline bool has_average_loss() const;
  inline void clear_average_loss();
  static const int kAverageLossFieldNumber = 33;
  inline ::google::protobuf::int32 average_loss() const;
  inline void set_average_loss(::google::protobuf::int32 value);

  // optional int32 max_iter = 7;
  inline bool has_max_iter() const;
  inline void clear_max_iter();
  static const int kMaxIterFieldNumber = 7;
  inline ::google::protobuf::int32 max_iter() const;
  inline void set_max_iter(::google::protobuf::int32 value);

  // optional int32 iter_size = 35 [default = 1];
  inline bool has_iter_size() const;
  inline void clear_iter_size();
  static const int kIterSizeFieldNumber = 35;
  inline ::google::protobuf::int32 iter_size() const;
  inline void set_iter_size(::google::protobuf::int32 value);

  // optional string lr_policy = 8;
  inline bool has_lr_policy() const;
  inline void clear_lr_policy();
  static const int kLrPolicyFieldNumber = 8;
  inline const ::std::string& lr_policy() const;
  inline void set_lr_policy(const ::std::string& value);
  inline void set_lr_policy(const char* value);
  inline void set_lr_policy(const char* value, size_t size);
  inline ::std::string* mutable_lr_policy();
  inline ::std::string* release_lr_policy();
  inline void set_allocated_lr_policy(::std::string* lr_policy);

  // optional float gamma = 9;
  inline bool has_gamma() const;
  inline void clear_gamma();
  static const int kGammaFieldNumber = 9;
  inline float gamma() const;
  inline void set_gamma(float value);

  // optional float power = 10;
  inline bool has_power() const;
  inline void clear_power();
  static const int kPowerFieldNumber = 10;
  inline float power() const;
  inline void set_power(float value);

  // optional float momentum = 11;
  inline bool has_momentum() const;
  inline void clear_momentum();
  static const int kMomentumFieldNumber = 11;
  inline float momentum() const;
  inline void set_momentum(float value);

  // optional float weight_decay = 12;
  inline bool has_weight_decay() const;
  inline void clear_weight_decay();
  static const int kWeightDecayFieldNumber = 12;
  inline float weight_decay() const;
  inline void set_weight_decay(float value);

  // optional string regularization_type = 29 [default = "L2"];
  inline bool has_regularization_type() const;
  inline void clear_regularization_type();
  static const int kRegularizationTypeFieldNumber = 29;
  inline const ::std::string& regularization_type() const;
  inline void set_regularization_type(const ::std::string& value);
  inline void set_regularization_type(const char* value);
  inline void set_regularization_type(const char* value, size_t size);
  inline ::std::string* mutable_regularization_type();
  inline ::std::string* release_regularization_type();
  inline void set_allocated_regularization_type(::std::string* regularization_type);

  // optional int32 stepsize = 13;
  inline bool has_stepsize() const;
  inline void clear_stepsize();
  static const int kStepsizeFieldNumber = 13;
  inline ::google::protobuf::int32 stepsize() const;
  inline void set_stepsize(::google::protobuf::int32 value);

  // repeated int32 stepvalue = 34;
  inline int stepvalue_size() const;
  inline void clear_stepvalue();
  static const int kStepvalueFieldNumber = 34;
  inline ::google::protobuf::int32 stepvalue(int index) const;
  inline void set_stepvalue(int index, ::google::protobuf::int32 value);
  inline void add_stepvalue(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      stepvalue() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_stepvalue();

  // optional int32 snapshot = 14 [default = 0];
  inline bool has_snapshot() const;
  inline void clear_snapshot();
  static const int kSnapshotFieldNumber = 14;
  inline ::google::protobuf::int32 snapshot() const;
  inline void set_snapshot(::google::protobuf::int32 value);

  // optional string snapshot_prefix = 15;
  inline bool has_snapshot_prefix() const;
  inline void clear_snapshot_prefix();
  static const int kSnapshotPrefixFieldNumber = 15;
  inline const ::std::string& snapshot_prefix() const;
  inline void set_snapshot_prefix(const ::std::string& value);
  inline void set_snapshot_prefix(const char* value);
  inline void set_snapshot_prefix(const char* value, size_t size);
  inline ::std::string* mutable_snapshot_prefix();
  inline ::std::string* release_snapshot_prefix();
  inline void set_allocated_snapshot_prefix(::std::string* snapshot_prefix);

  // optional bool snapshot_diff = 16 [default = false];
  inline bool has_snapshot_diff() const;
  inline void clear_snapshot_diff();
  static const int kSnapshotDiffFieldNumber = 16;
  inline bool snapshot_diff() const;
  inline void set_snapshot_diff(bool value);

  // optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
  inline bool has_solver_mode() const;
  inline void clear_solver_mode();
  static const int kSolverModeFieldNumber = 17;
  inline ::caffe::SolverParameter_SolverMode solver_mode() const;
  inline void set_solver_mode(::caffe::SolverParameter_SolverMode value);

  // optional int32 device_id = 18 [default = 0];
  inline bool has_device_id() const;
  inline void clear_device_id();
  static const int kDeviceIdFieldNumber = 18;
  inline ::google::protobuf::int32 device_id() const;
  inline void set_device_id(::google::protobuf::int32 value);

  // optional int64 random_seed = 20 [default = -1];
  inline bool has_random_seed() const;
  inline void clear_random_seed();
  static const int kRandomSeedFieldNumber = 20;
  inline ::google::protobuf::int64 random_seed() const;
  inline void set_random_seed(::google::protobuf::int64 value);

  // optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
  inline bool has_solver_type() const;
  inline void clear_solver_type();
  static const int kSolverTypeFieldNumber = 30;
  inline ::caffe::SolverParameter_SolverType solver_type() const;
  inline void set_solver_type(::caffe::SolverParameter_SolverType value);

  // optional float delta = 31 [default = 1e-08];
  inline bool has_delta() const;
  inline void clear_delta();
  static const int kDeltaFieldNumber = 31;
  inline float delta() const;
  inline void set_delta(float value);

  // optional bool debug_info = 23 [default = false];
  inline bool has_debug_info() const;
  inline void clear_debug_info();
  static const int kDebugInfoFieldNumber = 23;
  inline bool debug_info() const;
  inline void set_debug_info(bool value);

  // optional bool snapshot_after_train = 28 [default = true];
  inline bool has_snapshot_after_train() const;
  inline void clear_snapshot_after_train();
  static const int kSnapshotAfterTrainFieldNumber = 28;
  inline bool snapshot_after_train() const;
  inline void set_snapshot_after_train(bool value);

  // @@protoc_insertion_point(class_scope:caffe.SolverParameter)
 private:
  inline void set_has_net();
  inline void clear_has_net();
  inline void set_has_net_param();
  inline void clear_has_net_param();
  inline void set_has_train_net();
  inline void clear_has_train_net();
  inline void set_has_train_net_param();
  inline void clear_has_train_net_param();
  inline void set_has_train_state();
  inline void clear_has_train_state();
  inline void set_has_test_interval();
  inline void clear_has_test_interval();
  inline void set_has_test_compute_loss();
  inline void clear_has_test_compute_loss();
  inline void set_has_test_initialization();
  inline void clear_has_test_initialization();
  inline void set_has_base_lr();
  inline void clear_has_base_lr();
  inline void set_has_display();
  inline void clear_has_display();
  inline void set_has_average_loss();
  inline void clear_has_average_loss();
  inline void set_has_max_iter();
  inline void clear_has_max_iter();
  inline void set_has_iter_size();
  inline void clear_has_iter_size();
  inline void set_has_lr_policy();
  inline void clear_has_lr_policy();
  inline void set_has_gamma();
  inline void clear_has_gamma();
  inline void set_has_power();
  inline void clear_has_power();
  inline void set_has_momentum();
  inline void clear_has_momentum();
  inline void set_has_weight_decay();
  inline void clear_has_weight_decay();
  inline void set_has_regularization_type();
  inline void clear_has_regularization_type();
  inline void set_has_stepsize();
  inline void clear_has_stepsize();
  inline void set_has_snapshot();
  inline void clear_has_snapshot();
  inline void set_has_snapshot_prefix();
  inline void clear_has_snapshot_prefix();
  inline void set_has_snapshot_diff();
  inline void clear_has_snapshot_diff();
  inline void set_has_solver_mode();
  inline void clear_has_solver_mode();
  inline void set_has_device_id();
  inline void clear_has_device_id();
  inline void set_has_random_seed();
  inline void clear_has_random_seed();
  inline void set_has_solver_type();
  inline void clear_has_solver_type();
  inline void set_has_delta();
  inline void clear_has_delta();
  inline void set_has_debug_info();
  inline void clear_has_debug_info();
  inline void set_has_snapshot_after_train();
  inline void clear_has_snapshot_after_train();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* net_;
  ::caffe::NetParameter* net_param_;
  ::std::string* train_net_;
  ::google::protobuf::RepeatedPtrField< ::std::string> test_net_;
  ::caffe::NetParameter* train_net_param_;
  ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter > test_net_param_;
  ::caffe::NetState* train_state_;
  ::google::protobuf::RepeatedPtrField< ::caffe::NetState > test_state_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > test_iter_;
  ::google::protobuf::int32 test_interval_;
  float base_lr_;
  ::google::protobuf::int32 display_;
  ::google::protobuf::int32 average_loss_;
  ::google::protobuf::int32 max_iter_;
  ::google::protobuf::int32 iter_size_;
  ::std::string* lr_policy_;
  float gamma_;
  float power_;
  float momentum_;
  bool test_compute_loss_;
  bool test_initialization_;
  bool snapshot_diff_;
  bool debug_info_;
  float weight_decay_;
  ::google::protobuf::int32 stepsize_;
  ::std::string* regularization_type_;
  static ::std::string* _default_regularization_type_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > stepvalue_;
  ::std::string* snapshot_prefix_;
  ::google::protobuf::int32 snapshot_;
  int solver_mode_;
  ::google::protobuf::int64 random_seed_;
  ::google::protobuf::int32 device_id_;
  int solver_type_;
  float delta_;
  bool snapshot_after_train_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(35 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static SolverParameter* default_instance_;
};
// -------------------------------------------------------------------

class SolverState : public ::google::protobuf::Message {
 public:
  SolverState();
  virtual ~SolverState();

  SolverState(const SolverState& from);

  inline SolverState& operator=(const SolverState& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SolverState& default_instance();

  void Swap(SolverState* other);

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

  SolverState* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SolverState& from);
  void MergeFrom(const SolverState& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional int32 iter = 1;
  inline bool has_iter() const;
  inline void clear_iter();
  static const int kIterFieldNumber = 1;
  inline ::google::protobuf::int32 iter() const;
  inline void set_iter(::google::protobuf::int32 value);

  // optional string learned_net = 2;
  inline bool has_learned_net() const;
  inline void clear_learned_net();
  static const int kLearnedNetFieldNumber = 2;
  inline const ::std::string& learned_net() const;
  inline void set_learned_net(const ::std::string& value);
  inline void set_learned_net(const char* value);
  inline void set_learned_net(const char* value, size_t size);
  inline ::std::string* mutable_learned_net();
  inline ::std::string* release_learned_net();
  inline void set_allocated_learned_net(::std::string* learned_net);

  // repeated .caffe.BlobProto history = 3;
  inline int history_size() const;
  inline void clear_history();
  static const int kHistoryFieldNumber = 3;
  inline const ::caffe::BlobProto& history(int index) const;
  inline ::caffe::BlobProto* mutable_history(int index);
  inline ::caffe::BlobProto* add_history();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
      history() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
      mutable_history();

  // optional int32 current_step = 4 [default = 0];
  inline bool has_current_step() const;
  inline void clear_current_step();
  static const int kCurrentStepFieldNumber = 4;
  inline ::google::protobuf::int32 current_step() const;
  inline void set_current_step(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:caffe.SolverState)
 private:
  inline void set_has_iter();
  inline void clear_has_iter();
  inline void set_has_learned_net();
  inline void clear_has_learned_net();
  inline void set_has_current_step();
  inline void clear_has_current_step();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* learned_net_;
  ::google::protobuf::int32 iter_;
  ::google::protobuf::int32 current_step_;
  ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > history_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static SolverState* default_instance_;
};
// -------------------------------------------------------------------

class NetState : public ::google::protobuf::Message {
 public:
  NetState();
  virtual ~NetState();

  NetState(const NetState& from);

  inline NetState& operator=(const NetState& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NetState& default_instance();

  void Swap(NetState* other);

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

  NetState* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NetState& from);
  void MergeFrom(const NetState& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .caffe.Phase phase = 1 [default = TEST];
  inline bool has_phase() const;
  inline void clear_phase();
  static const int kPhaseFieldNumber = 1;
  inline ::caffe::Phase phase() const;
  inline void set_phase(::caffe::Phase value);

  // optional int32 level = 2 [default = 0];
  inline bool has_level() const;
  inline void clear_level();
  static const int kLevelFieldNumber = 2;
  inline ::google::protobuf::int32 level() const;
  inline void set_level(::google::protobuf::int32 value);

  // repeated string stage = 3;
  inline int stage_size() const;
  inline void clear_stage();
  static const int kStageFieldNumber = 3;
  inline const ::std::string& stage(int index) const;
  inline ::std::string* mutable_stage(int index);
  inline void set_stage(int index, const ::std::string& value);
  inline void set_stage(int index, const char* value);
  inline void set_stage(int index, const char* value, size_t size);
  inline ::std::string* add_stage();
  inline void add_stage(const ::std::string& value);
  inline void add_stage(const char* value);
  inline void add_stage(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& stage() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_stage();

  // @@protoc_insertion_point(class_scope:caffe.NetState)
 private:
  inline void set_has_phase();
  inline void clear_has_phase();
  inline void set_has_level();
  inline void clear_has_level();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int phase_;
  ::google::protobuf::int32 level_;
  ::google::protobuf::RepeatedPtrField< ::std::string> stage_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static NetState* default_instance_;
};
// -------------------------------------------------------------------

class NetStateRule : public ::google::protobuf::Message {
 public:
  NetStateRule();
  virtual ~NetStateRule();

  NetStateRule(const NetStateRule& from);

  inline NetStateRule& operator=(const NetStateRule& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const NetStateRule& default_instance();

  void Swap(NetStateRule* other);

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

  NetStateRule* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NetStateRule& from);
  void MergeFrom(const NetStateRule& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .caffe.Phase phase = 1;
  inline bool has_phase() const;
  inline void clear_phase();
  static const int kPhaseFieldNumber = 1;
  inline ::caffe::Phase phase() const;
  inline void set_phase(::caffe::Phase value);

  // optional int32 min_level = 2;
  inline bool has_min_level() const;
  inline void clear_min_level();
  static const int kMinLevelFieldNumber = 2;
  inline ::google::protobuf::int32 min_level() const;
  inline void set_min_level(::google::protobuf::int32 value);

  // optional int32 max_level = 3;
  inline bool has_max_level() const;
  inline void clear_max_level();
  static const int kMaxLevelFieldNumber = 3;
  inline ::google::protobuf::int32 max_level() const;
  inline void set_max_level(::google::protobuf::int32 value);

  // repeated string stage = 4;
  inline int stage_size() const;
  inline void clear_stage();
  static const int kStageFieldNumber = 4;
  inline const ::std::string& stage(int index) const;
  inline ::std::string* mutable_stage(int index);
  inline void set_stage(int index, const ::std::string& value);
  inline void set_stage(int index, const char* value);
  inline void set_stage(int index, const char* value, size_t size);
  inline ::std::string* add_stage();
  inline void add_stage(const ::std::string& value);
  inline void add_stage(const char* value);
  inline void add_stage(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& stage() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_stage();

  // repeated string not_stage = 5;
  inline int not_stage_size() const;
  inline void clear_not_stage();
  static const int kNotStageFieldNumber = 5;
  inline const ::std::string& not_stage(int index) const;
  inline ::std::string* mutable_not_stage(int index);
  inline void set_not_stage(int index, const ::std::string& value);
  inline void set_not_stage(int index, const char* value);
  inline void set_not_stage(int index, const char* value, size_t size);
  inline ::std::string* add_not_stage();
  inline void add_not_stage(const ::std::string& value);
  inline void add_not_stage(const char* value);
  inline void add_not_stage(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& not_stage() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_not_stage();

  // @@protoc_insertion_point(class_scope:caffe.NetStateRule)
 private:
  inline void set_has_phase();
  inline void clear_has_phase();
  inline void set_has_min_level();
  inline void clear_has_min_level();
  inline void set_has_max_level();
  inline void clear_has_max_level();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int phase_;
  ::google::protobuf::int32 min_level_;
  ::google::protobuf::RepeatedPtrField< ::std::string> stage_;
  ::google::protobuf::RepeatedPtrField< ::std::string> not_stage_;
  ::google::protobuf::int32 max_level_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static NetStateRule* default_instance_;
};
// -------------------------------------------------------------------

class LayerParameter : public ::google::protobuf::Message {
 public:
  LayerParameter();
  virtual ~LayerParameter();

  LayerParameter(const LayerParameter& from);

  inline LayerParameter& operator=(const LayerParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LayerParameter& default_instance();

  void Swap(LayerParameter* other);

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

  LayerParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LayerParameter& from);
  void MergeFrom(const LayerParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef LayerParameter_LayerType LayerType;
  static const LayerType NONE = LayerParameter_LayerType_NONE;
  static const LayerType ABSVAL = LayerParameter_LayerType_ABSVAL;
  static const LayerType ACCURACY = LayerParameter_LayerType_ACCURACY;
  static const LayerType ARGMAX = LayerParameter_LayerType_ARGMAX;
  static const LayerType BNLL = LayerParameter_LayerType_BNLL;
  static const LayerType CONCAT = LayerParameter_LayerType_CONCAT;
  static const LayerType CONTRASTIVE_LOSS = LayerParameter_LayerType_CONTRASTIVE_LOSS;
  static const LayerType CONVOLUTION = LayerParameter_LayerType_CONVOLUTION;
  static const LayerType CROP = LayerParameter_LayerType_CROP;
  static const LayerType DATA = LayerParameter_LayerType_DATA;
  static const LayerType DECONVOLUTION = LayerParameter_LayerType_DECONVOLUTION;
  static const LayerType DROPOUT = LayerParameter_LayerType_DROPOUT;
  static const LayerType DUMMY_DATA = LayerParameter_LayerType_DUMMY_DATA;
  static const LayerType EUCLIDEAN_LOSS = LayerParameter_LayerType_EUCLIDEAN_LOSS;
  static const LayerType ELTWISE = LayerParameter_LayerType_ELTWISE;
  static const LayerType EXP = LayerParameter_LayerType_EXP;
  static const LayerType FLATTEN = LayerParameter_LayerType_FLATTEN;
  static const LayerType HDF5_DATA = LayerParameter_LayerType_HDF5_DATA;
  static const LayerType HDF5_OUTPUT = LayerParameter_LayerType_HDF5_OUTPUT;
  static const LayerType HINGE_LOSS = LayerParameter_LayerType_HINGE_LOSS;
  static const LayerType IM2COL = LayerParameter_LayerType_IM2COL;
  static const LayerType IMAGE_DATA = LayerParameter_LayerType_IMAGE_DATA;
  static const LayerType INFOGAIN_LOSS = LayerParameter_LayerType_INFOGAIN_LOSS;
  static const LayerType INNER_PRODUCT = LayerParameter_LayerType_INNER_PRODUCT;
  static const LayerType LRN = LayerParameter_LayerType_LRN;
  static const LayerType MEMORY_DATA = LayerParameter_LayerType_MEMORY_DATA;
  static const LayerType MULTI_STAGE_MEANFIELD = LayerParameter_LayerType_MULTI_STAGE_MEANFIELD;
  static const LayerType MULTINOMIAL_LOGISTIC_LOSS = LayerParameter_LayerType_MULTINOMIAL_LOGISTIC_LOSS;
  static const LayerType MVN = LayerParameter_LayerType_MVN;
  static const LayerType POOLING = LayerParameter_LayerType_POOLING;
  static const LayerType POWER = LayerParameter_LayerType_POWER;
  static const LayerType RELU = LayerParameter_LayerType_RELU;
  static const LayerType SIGMOID = LayerParameter_LayerType_SIGMOID;
  static const LayerType SIGMOID_CROSS_ENTROPY_LOSS = LayerParameter_LayerType_SIGMOID_CROSS_ENTROPY_LOSS;
  static const LayerType SILENCE = LayerParameter_LayerType_SILENCE;
  static const LayerType SIMPLE_FAST_MEANFIELD = LayerParameter_LayerType_SIMPLE_FAST_MEANFIELD;
  static const LayerType SOFTMAX = LayerParameter_LayerType_SOFTMAX;
  static const LayerType SOFTMAX_LOSS = LayerParameter_LayerType_SOFTMAX_LOSS;
  static const LayerType SPLIT = LayerParameter_LayerType_SPLIT;
  static const LayerType SLICE = LayerParameter_LayerType_SLICE;
  static const LayerType TANH = LayerParameter_LayerType_TANH;
  static const LayerType WINDOW_DATA = LayerParameter_LayerType_WINDOW_DATA;
  static const LayerType THRESHOLD = LayerParameter_LayerType_THRESHOLD;
  static inline bool LayerType_IsValid(int value) {
    return LayerParameter_LayerType_IsValid(value);
  }
  static const LayerType LayerType_MIN =
    LayerParameter_LayerType_LayerType_MIN;
  static const LayerType LayerType_MAX =
    LayerParameter_LayerType_LayerType_MAX;
  static const int LayerType_ARRAYSIZE =
    LayerParameter_LayerType_LayerType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  LayerType_descriptor() {
    return LayerParameter_LayerType_descriptor();
  }
  static inline const ::std::string& LayerType_Name(LayerType value) {
    return LayerParameter_LayerType_Name(value);
  }
  static inline bool LayerType_Parse(const ::std::string& name,
      LayerType* value) {
    return LayerParameter_LayerType_Parse(name, value);
  }

  typedef LayerParameter_DimCheckMode DimCheckMode;
  static const DimCheckMode STRICT = LayerParameter_DimCheckMode_STRICT;
  static const DimCheckMode PERMISSIVE = LayerParameter_DimCheckMode_PERMISSIVE;
  static inline bool DimCheckMode_IsValid(int value) {
    return LayerParameter_DimCheckMode_IsValid(value);
  }
  static const DimCheckMode DimCheckMode_MIN =
    LayerParameter_DimCheckMode_DimCheckMode_MIN;
  static const DimCheckMode DimCheckMode_MAX =
    LayerParameter_DimCheckMode_DimCheckMode_MAX;
  static const int DimCheckMode_ARRAYSIZE =
    LayerParameter_DimCheckMode_DimCheckMode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  DimCheckMode_descriptor() {
    return LayerParameter_DimCheckMode_descriptor();
  }
  static inline const ::std::string& DimCheckMode_Name(DimCheckMode value) {
    return LayerParameter_DimCheckMode_Name(value);
  }
  static inline bool DimCheckMode_Parse(const ::std::string& name,
      DimCheckMode* value) {
    return LayerParameter_DimCheckMode_Parse(name, value);
  }

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

  // repeated string bottom = 2;
  inline int bottom_size() const;
  inline void clear_bottom();
  static const int kBottomFieldNumber = 2;
  inline const ::std::string& bottom(int index) const;
  inline ::std::string* mutable_bottom(int index);
  inline void set_bottom(int index, const ::std::string& value);
  inline void set_bottom(int index, const char* value);
  inline void set_bottom(int index, const char* value, size_t size);
  inline ::std::string* add_bottom();
  inline void add_bottom(const ::std::string& value);
  inline void add_bottom(const char* value);
  inline void add_bottom(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& bottom() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_bottom();

  // repeated string top = 3;
  inline int top_size() const;
  inline void clear_top();
  static const int kTopFieldNumber = 3;
  inline const ::std::string& top(int index) const;
  inline ::std::string* mutable_top(int index);
  inline void set_top(int index, const ::std::string& value);
  inline void set_top(int index, const char* value);
  inline void set_top(int index, const char* value, size_t size);
  inline ::std::string* add_top();
  inline void add_top(const ::std::string& value);
  inline void add_top(const char* value);
  inline void add_top(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& top() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_top();

  // optional string name = 4;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 4;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // repeated .caffe.NetStateRule include = 32;
  inline int include_size() const;
  inline void clear_include();
  static const int kIncludeFieldNumber = 32;
  inline const ::caffe::NetStateRule& include(int index) const;
  inline ::caffe::NetStateRule* mutable_include(int index);
  inline ::caffe::NetStateRule* add_include();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >&
      include() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >*
      mutable_include();

  // repeated .caffe.NetStateRule exclude = 33;
  inline int exclude_size() const;
  inline void clear_exclude();
  static const int kExcludeFieldNumber = 33;
  inline const ::caffe::NetStateRule& exclude(int index) const;
  inline ::caffe::NetStateRule* mutable_exclude(int index);
  inline ::caffe::NetStateRule* add_exclude();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >&
      exclude() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >*
      mutable_exclude();

  // optional .caffe.LayerParameter.LayerType type = 5;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 5;
  inline ::caffe::LayerParameter_LayerType type() const;
  inline void set_type(::caffe::LayerParameter_LayerType value);

  // repeated .caffe.BlobProto blobs = 6;
  inline int blobs_size() const;
  inline void clear_blobs();
  static const int kBlobsFieldNumber = 6;
  inline const ::caffe::BlobProto& blobs(int index) const;
  inline ::caffe::BlobProto* mutable_blobs(int index);
  inline ::caffe::BlobProto* add_blobs();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
      blobs() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
      mutable_blobs();

  // repeated string param = 1001;
  inline int param_size() const;
  inline void clear_param();
  static const int kParamFieldNumber = 1001;
  inline const ::std::string& param(int index) const;
  inline ::std::string* mutable_param(int index);
  inline void set_param(int index, const ::std::string& value);
  inline void set_param(int index, const char* value);
  inline void set_param(int index, const char* value, size_t size);
  inline ::std::string* add_param();
  inline void add_param(const ::std::string& value);
  inline void add_param(const char* value);
  inline void add_param(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& param() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_param();

  // repeated .caffe.LayerParameter.DimCheckMode blob_share_mode = 1002;
  inline int blob_share_mode_size() const;
  inline void clear_blob_share_mode();
  static const int kBlobShareModeFieldNumber = 1002;
  inline ::caffe::LayerParameter_DimCheckMode blob_share_mode(int index) const;
  inline void set_blob_share_mode(int index, ::caffe::LayerParameter_DimCheckMode value);
  inline void add_blob_share_mode(::caffe::LayerParameter_DimCheckMode value);
  inline const ::google::protobuf::RepeatedField<int>& blob_share_mode() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_blob_share_mode();

  // repeated float blobs_lr = 7;
  inline int blobs_lr_size() const;
  inline void clear_blobs_lr();
  static const int kBlobsLrFieldNumber = 7;
  inline float blobs_lr(int index) const;
  inline void set_blobs_lr(int index, float value);
  inline void add_blobs_lr(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      blobs_lr() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_blobs_lr();

  // repeated float weight_decay = 8;
  inline int weight_decay_size() const;
  inline void clear_weight_decay();
  static const int kWeightDecayFieldNumber = 8;
  inline float weight_decay(int index) const;
  inline void set_weight_decay(int index, float value);
  inline void add_weight_decay(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      weight_decay() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_weight_decay();

  // repeated float loss_weight = 35;
  inline int loss_weight_size() const;
  inline void clear_loss_weight();
  static const int kLossWeightFieldNumber = 35;
  inline float loss_weight(int index) const;
  inline void set_loss_weight(int index, float value);
  inline void add_loss_weight(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      loss_weight() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_loss_weight();

  // optional .caffe.AccuracyParameter accuracy_param = 27;
  inline bool has_accuracy_param() const;
  inline void clear_accuracy_param();
  static const int kAccuracyParamFieldNumber = 27;
  inline const ::caffe::AccuracyParameter& accuracy_param() const;
  inline ::caffe::AccuracyParameter* mutable_accuracy_param();
  inline ::caffe::AccuracyParameter* release_accuracy_param();
  inline void set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param);

  // optional .caffe.ArgMaxParameter argmax_param = 23;
  inline bool has_argmax_param() const;
  inline void clear_argmax_param();
  static const int kArgmaxParamFieldNumber = 23;
  inline const ::caffe::ArgMaxParameter& argmax_param() const;
  inline ::caffe::ArgMaxParameter* mutable_argmax_param();
  inline ::caffe::ArgMaxParameter* release_argmax_param();
  inline void set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param);

  // optional .caffe.ConcatParameter concat_param = 9;
  inline bool has_concat_param() const;
  inline void clear_concat_param();
  static const int kConcatParamFieldNumber = 9;
  inline const ::caffe::ConcatParameter& concat_param() const;
  inline ::caffe::ConcatParameter* mutable_concat_param();
  inline ::caffe::ConcatParameter* release_concat_param();
  inline void set_allocated_concat_param(::caffe::ConcatParameter* concat_param);

  // optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40;
  inline bool has_contrastive_loss_param() const;
  inline void clear_contrastive_loss_param();
  static const int kContrastiveLossParamFieldNumber = 40;
  inline const ::caffe::ContrastiveLossParameter& contrastive_loss_param() const;
  inline ::caffe::ContrastiveLossParameter* mutable_contrastive_loss_param();
  inline ::caffe::ContrastiveLossParameter* release_contrastive_loss_param();
  inline void set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param);

  // optional .caffe.ConvolutionParameter convolution_param = 10;
  inline bool has_convolution_param() const;
  inline void clear_convolution_param();
  static const int kConvolutionParamFieldNumber = 10;
  inline const ::caffe::ConvolutionParameter& convolution_param() const;
  inline ::caffe::ConvolutionParameter* mutable_convolution_param();
  inline ::caffe::ConvolutionParameter* release_convolution_param();
  inline void set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param);

  // optional .caffe.DataParameter data_param = 11;
  inline bool has_data_param() const;
  inline void clear_data_param();
  static const int kDataParamFieldNumber = 11;
  inline const ::caffe::DataParameter& data_param() const;
  inline ::caffe::DataParameter* mutable_data_param();
  inline ::caffe::DataParameter* release_data_param();
  inline void set_allocated_data_param(::caffe::DataParameter* data_param);

  // optional .caffe.DropoutParameter dropout_param = 12;
  inline bool has_dropout_param() const;
  inline void clear_dropout_param();
  static const int kDropoutParamFieldNumber = 12;
  inline const ::caffe::DropoutParameter& dropout_param() const;
  inline ::caffe::DropoutParameter* mutable_dropout_param();
  inline ::caffe::DropoutParameter* release_dropout_param();
  inline void set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param);

  // optional .caffe.DummyDataParameter dummy_data_param = 26;
  inline bool has_dummy_data_param() const;
  inline void clear_dummy_data_param();
  static const int kDummyDataParamFieldNumber = 26;
  inline const ::caffe::DummyDataParameter& dummy_data_param() const;
  inline ::caffe::DummyDataParameter* mutable_dummy_data_param();
  inline ::caffe::DummyDataParameter* release_dummy_data_param();
  inline void set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param);

  // optional .caffe.EltwiseParameter eltwise_param = 24;
  inline bool has_eltwise_param() const;
  inline void clear_eltwise_param();
  static const int kEltwiseParamFieldNumber = 24;
  inline const ::caffe::EltwiseParameter& eltwise_param() const;
  inline ::caffe::EltwiseParameter* mutable_eltwise_param();
  inline ::caffe::EltwiseParameter* release_eltwise_param();
  inline void set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param);

  // optional .caffe.ExpParameter exp_param = 41;
  inline bool has_exp_param() const;
  inline void clear_exp_param();
  static const int kExpParamFieldNumber = 41;
  inline const ::caffe::ExpParameter& exp_param() const;
  inline ::caffe::ExpParameter* mutable_exp_param();
  inline ::caffe::ExpParameter* release_exp_param();
  inline void set_allocated_exp_param(::caffe::ExpParameter* exp_param);

  // optional .caffe.HDF5DataParameter hdf5_data_param = 13;
  inline bool has_hdf5_data_param() const;
  inline void clear_hdf5_data_param();
  static const int kHdf5DataParamFieldNumber = 13;
  inline const ::caffe::HDF5DataParameter& hdf5_data_param() const;
  inline ::caffe::HDF5DataParameter* mutable_hdf5_data_param();
  inline ::caffe::HDF5DataParameter* release_hdf5_data_param();
  inline void set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param);

  // optional .caffe.HDF5OutputParameter hdf5_output_param = 14;
  inline bool has_hdf5_output_param() const;
  inline void clear_hdf5_output_param();
  static const int kHdf5OutputParamFieldNumber = 14;
  inline const ::caffe::HDF5OutputParameter& hdf5_output_param() const;
  inline ::caffe::HDF5OutputParameter* mutable_hdf5_output_param();
  inline ::caffe::HDF5OutputParameter* release_hdf5_output_param();
  inline void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param);

  // optional .caffe.HingeLossParameter hinge_loss_param = 29;
  inline bool has_hinge_loss_param() const;
  inline void clear_hinge_loss_param();
  static const int kHingeLossParamFieldNumber = 29;
  inline const ::caffe::HingeLossParameter& hinge_loss_param() const;
  inline ::caffe::HingeLossParameter* mutable_hinge_loss_param();
  inline ::caffe::HingeLossParameter* release_hinge_loss_param();
  inline void set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param);

  // optional .caffe.ImageDataParameter image_data_param = 15;
  inline bool has_image_data_param() const;
  inline void clear_image_data_param();
  static const int kImageDataParamFieldNumber = 15;
  inline const ::caffe::ImageDataParameter& image_data_param() const;
  inline ::caffe::ImageDataParameter* mutable_image_data_param();
  inline ::caffe::ImageDataParameter* release_image_data_param();
  inline void set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param);

  // optional .caffe.InfogainLossParameter infogain_loss_param = 16;
  inline bool has_infogain_loss_param() const;
  inline void clear_infogain_loss_param();
  static const int kInfogainLossParamFieldNumber = 16;
  inline const ::caffe::InfogainLossParameter& infogain_loss_param() const;
  inline ::caffe::InfogainLossParameter* mutable_infogain_loss_param();
  inline ::caffe::InfogainLossParameter* release_infogain_loss_param();
  inline void set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param);

  // optional .caffe.InnerProductParameter inner_product_param = 17;
  inline bool has_inner_product_param() const;
  inline void clear_inner_product_param();
  static const int kInnerProductParamFieldNumber = 17;
  inline const ::caffe::InnerProductParameter& inner_product_param() const;
  inline ::caffe::InnerProductParameter* mutable_inner_product_param();
  inline ::caffe::InnerProductParameter* release_inner_product_param();
  inline void set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param);

  // optional .caffe.LRNParameter lrn_param = 18;
  inline bool has_lrn_param() const;
  inline void clear_lrn_param();
  static const int kLrnParamFieldNumber = 18;
  inline const ::caffe::LRNParameter& lrn_param() const;
  inline ::caffe::LRNParameter* mutable_lrn_param();
  inline ::caffe::LRNParameter* release_lrn_param();
  inline void set_allocated_lrn_param(::caffe::LRNParameter* lrn_param);

  // optional .caffe.MultiStageMeanfieldParameter multi_stage_meanfield_param = 44;
  inline bool has_multi_stage_meanfield_param() const;
  inline void clear_multi_stage_meanfield_param();
  static const int kMultiStageMeanfieldParamFieldNumber = 44;
  inline const ::caffe::MultiStageMeanfieldParameter& multi_stage_meanfield_param() const;
  inline ::caffe::MultiStageMeanfieldParameter* mutable_multi_stage_meanfield_param();
  inline ::caffe::MultiStageMeanfieldParameter* release_multi_stage_meanfield_param();
  inline void set_allocated_multi_stage_meanfield_param(::caffe::MultiStageMeanfieldParameter* multi_stage_meanfield_param);

  // optional .caffe.MemoryDataParameter memory_data_param = 22;
  inline bool has_memory_data_param() const;
  inline void clear_memory_data_param();
  static const int kMemoryDataParamFieldNumber = 22;
  inline const ::caffe::MemoryDataParameter& memory_data_param() const;
  inline ::caffe::MemoryDataParameter* mutable_memory_data_param();
  inline ::caffe::MemoryDataParameter* release_memory_data_param();
  inline void set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param);

  // optional .caffe.MVNParameter mvn_param = 34;
  inline bool has_mvn_param() const;
  inline void clear_mvn_param();
  static const int kMvnParamFieldNumber = 34;
  inline const ::caffe::MVNParameter& mvn_param() const;
  inline ::caffe::MVNParameter* mutable_mvn_param();
  inline ::caffe::MVNParameter* release_mvn_param();
  inline void set_allocated_mvn_param(::caffe::MVNParameter* mvn_param);

  // optional .caffe.PoolingParameter pooling_param = 19;
  inline bool has_pooling_param() const;
  inline void clear_pooling_param();
  static const int kPoolingParamFieldNumber = 19;
  inline const ::caffe::PoolingParameter& pooling_param() const;
  inline ::caffe::PoolingParameter* mutable_pooling_param();
  inline ::caffe::PoolingParameter* release_pooling_param();
  inline void set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param);

  // optional .caffe.PowerParameter power_param = 21;
  inline bool has_power_param() const;
  inline void clear_power_param();
  static const int kPowerParamFieldNumber = 21;
  inline const ::caffe::PowerParameter& power_param() const;
  inline ::caffe::PowerParameter* mutable_power_param();
  inline ::caffe::PowerParameter* release_power_param();
  inline void set_allocated_power_param(::caffe::PowerParameter* power_param);

  // optional .caffe.ReLUParameter relu_param = 30;
  inline bool has_relu_param() const;
  inline void clear_relu_param();
  static const int kReluParamFieldNumber = 30;
  inline const ::caffe::ReLUParameter& relu_param() const;
  inline ::caffe::ReLUParameter* mutable_relu_param();
  inline ::caffe::ReLUParameter* release_relu_param();
  inline void set_allocated_relu_param(::caffe::ReLUParameter* relu_param);

  // optional .caffe.SigmoidParameter sigmoid_param = 38;
  inline bool has_sigmoid_param() const;
  inline void clear_sigmoid_param();
  static const int kSigmoidParamFieldNumber = 38;
  inline const ::caffe::SigmoidParameter& sigmoid_param() const;
  inline ::caffe::SigmoidParameter* mutable_sigmoid_param();
  inline ::caffe::SigmoidParameter* release_sigmoid_param();
  inline void set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param);

  // optional .caffe.SoftmaxParameter softmax_param = 39;
  inline bool has_softmax_param() const;
  inline void clear_softmax_param();
  static const int kSoftmaxParamFieldNumber = 39;
  inline const ::caffe::SoftmaxParameter& softmax_param() const;
  inline ::caffe::SoftmaxParameter* mutable_softmax_param();
  inline ::caffe::SoftmaxParameter* release_softmax_param();
  inline void set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param);

  // optional .caffe.SliceParameter slice_param = 31;
  inline bool has_slice_param() const;
  inline void clear_slice_param();
  static const int kSliceParamFieldNumber = 31;
  inline const ::caffe::SliceParameter& slice_param() const;
  inline ::caffe::SliceParameter* mutable_slice_param();
  inline ::caffe::SliceParameter* release_slice_param();
  inline void set_allocated_slice_param(::caffe::SliceParameter* slice_param);

  // optional .caffe.TanHParameter tanh_param = 37;
  inline bool has_tanh_param() const;
  inline void clear_tanh_param();
  static const int kTanhParamFieldNumber = 37;
  inline const ::caffe::TanHParameter& tanh_param() const;
  inline ::caffe::TanHParameter* mutable_tanh_param();
  inline ::caffe::TanHParameter* release_tanh_param();
  inline void set_allocated_tanh_param(::caffe::TanHParameter* tanh_param);

  // optional .caffe.ThresholdParameter threshold_param = 25;
  inline bool has_threshold_param() const;
  inline void clear_threshold_param();
  static const int kThresholdParamFieldNumber = 25;
  inline const ::caffe::ThresholdParameter& threshold_param() const;
  inline ::caffe::ThresholdParameter* mutable_threshold_param();
  inline ::caffe::ThresholdParameter* release_threshold_param();
  inline void set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param);

  // optional .caffe.WindowDataParameter window_data_param = 20;
  inline bool has_window_data_param() const;
  inline void clear_window_data_param();
  static const int kWindowDataParamFieldNumber = 20;
  inline const ::caffe::WindowDataParameter& window_data_param() const;
  inline ::caffe::WindowDataParameter* mutable_window_data_param();
  inline ::caffe::WindowDataParameter* release_window_data_param();
  inline void set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param);

  // optional .caffe.TransformationParameter transform_param = 36;
  inline bool has_transform_param() const;
  inline void clear_transform_param();
  static const int kTransformParamFieldNumber = 36;
  inline const ::caffe::TransformationParameter& transform_param() const;
  inline ::caffe::TransformationParameter* mutable_transform_param();
  inline ::caffe::TransformationParameter* release_transform_param();
  inline void set_allocated_transform_param(::caffe::TransformationParameter* transform_param);

  // optional .caffe.LossParameter loss_param = 42;
  inline bool has_loss_param() const;
  inline void clear_loss_param();
  static const int kLossParamFieldNumber = 42;
  inline const ::caffe::LossParameter& loss_param() const;
  inline ::caffe::LossParameter* mutable_loss_param();
  inline ::caffe::LossParameter* release_loss_param();
  inline void set_allocated_loss_param(::caffe::LossParameter* loss_param);

  // optional .caffe.V0LayerParameter layer = 1;
  inline bool has_layer() const;
  inline void clear_layer();
  static const int kLayerFieldNumber = 1;
  inline const ::caffe::V0LayerParameter& layer() const;
  inline ::caffe::V0LayerParameter* mutable_layer();
  inline ::caffe::V0LayerParameter* release_layer();
  inline void set_allocated_layer(::caffe::V0LayerParameter* layer);

  // @@protoc_insertion_point(class_scope:caffe.LayerParameter)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_accuracy_param();
  inline void clear_has_accuracy_param();
  inline void set_has_argmax_param();
  inline void clear_has_argmax_param();
  inline void set_has_concat_param();
  inline void clear_has_concat_param();
  inline void set_has_contrastive_loss_param();
  inline void clear_has_contrastive_loss_param();
  inline void set_has_convolution_param();
  inline void clear_has_convolution_param();
  inline void set_has_data_param();
  inline void clear_has_data_param();
  inline void set_has_dropout_param();
  inline void clear_has_dropout_param();
  inline void set_has_dummy_data_param();
  inline void clear_has_dummy_data_param();
  inline void set_has_eltwise_param();
  inline void clear_has_eltwise_param();
  inline void set_has_exp_param();
  inline void clear_has_exp_param();
  inline void set_has_hdf5_data_param();
  inline void clear_has_hdf5_data_param();
  inline void set_has_hdf5_output_param();
  inline void clear_has_hdf5_output_param();
  inline void set_has_hinge_loss_param();
  inline void clear_has_hinge_loss_param();
  inline void set_has_image_data_param();
  inline void clear_has_image_data_param();
  inline void set_has_infogain_loss_param();
  inline void clear_has_infogain_loss_param();
  inline void set_has_inner_product_param();
  inline void clear_has_inner_product_param();
  inline void set_has_lrn_param();
  inline void clear_has_lrn_param();
  inline void set_has_multi_stage_meanfield_param();
  inline void clear_has_multi_stage_meanfield_param();
  inline void set_has_memory_data_param();
  inline void clear_has_memory_data_param();
  inline void set_has_mvn_param();
  inline void clear_has_mvn_param();
  inline void set_has_pooling_param();
  inline void clear_has_pooling_param();
  inline void set_has_power_param();
  inline void clear_has_power_param();
  inline void set_has_relu_param();
  inline void clear_has_relu_param();
  inline void set_has_sigmoid_param();
  inline void clear_has_sigmoid_param();
  inline void set_has_softmax_param();
  inline void clear_has_softmax_param();
  inline void set_has_slice_param();
  inline void clear_has_slice_param();
  inline void set_has_tanh_param();
  inline void clear_has_tanh_param();
  inline void set_has_threshold_param();
  inline void clear_has_threshold_param();
  inline void set_has_window_data_param();
  inline void clear_has_window_data_param();
  inline void set_has_transform_param();
  inline void clear_has_transform_param();
  inline void set_has_loss_param();
  inline void clear_has_loss_param();
  inline void set_has_layer();
  inline void clear_has_layer();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::std::string> bottom_;
  ::google::protobuf::RepeatedPtrField< ::std::string> top_;
  ::std::string* name_;
  ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule > include_;
  ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule > exclude_;
  ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_;
  ::google::protobuf::RepeatedPtrField< ::std::string> param_;
  ::google::protobuf::RepeatedField<int> blob_share_mode_;
  ::google::protobuf::RepeatedField< float > blobs_lr_;
  ::google::protobuf::RepeatedField< float > weight_decay_;
  ::google::protobuf::RepeatedField< float > loss_weight_;
  ::caffe::AccuracyParameter* accuracy_param_;
  ::caffe::ArgMaxParameter* argmax_param_;
  ::caffe::ConcatParameter* concat_param_;
  ::caffe::ContrastiveLossParameter* contrastive_loss_param_;
  ::caffe::ConvolutionParameter* convolution_param_;
  ::caffe::DataParameter* data_param_;
  ::caffe::DropoutParameter* dropout_param_;
  ::caffe::DummyDataParameter* dummy_data_param_;
  ::caffe::EltwiseParameter* eltwise_param_;
  ::caffe::ExpParameter* exp_param_;
  ::caffe::HDF5DataParameter* hdf5_data_param_;
  ::caffe::HDF5OutputParameter* hdf5_output_param_;
  ::caffe::HingeLossParameter* hinge_loss_param_;
  ::caffe::ImageDataParameter* image_data_param_;
  ::caffe::InfogainLossParameter* infogain_loss_param_;
  ::caffe::InnerProductParameter* inner_product_param_;
  ::caffe::LRNParameter* lrn_param_;
  ::caffe::MultiStageMeanfieldParameter* multi_stage_meanfield_param_;
  ::caffe::MemoryDataParameter* memory_data_param_;
  ::caffe::MVNParameter* mvn_param_;
  ::caffe::PoolingParameter* pooling_param_;
  ::caffe::PowerParameter* power_param_;
  ::caffe::ReLUParameter* relu_param_;
  ::caffe::SigmoidParameter* sigmoid_param_;
  ::caffe::SoftmaxParameter* softmax_param_;
  ::caffe::SliceParameter* slice_param_;
  ::caffe::TanHParameter* tanh_param_;
  ::caffe::ThresholdParameter* threshold_param_;
  ::caffe::WindowDataParameter* window_data_param_;
  ::caffe::TransformationParameter* transform_param_;
  ::caffe::LossParameter* loss_param_;
  ::caffe::V0LayerParameter* layer_;
  int type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(44 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static LayerParameter* default_instance_;
};
// -------------------------------------------------------------------

class TransformationParameter : public ::google::protobuf::Message {
 public:
  TransformationParameter();
  virtual ~TransformationParameter();

  TransformationParameter(const TransformationParameter& from);

  inline TransformationParameter& operator=(const TransformationParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TransformationParameter& default_instance();

  void Swap(TransformationParameter* other);

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

  TransformationParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TransformationParameter& from);
  void MergeFrom(const TransformationParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional float scale = 1 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 1;
  inline float scale() const;
  inline void set_scale(float value);

  // optional bool mirror = 2 [default = false];
  inline bool has_mirror() const;
  inline void clear_mirror();
  static const int kMirrorFieldNumber = 2;
  inline bool mirror() const;
  inline void set_mirror(bool value);

  // optional uint32 crop_size = 3 [default = 0];
  inline bool has_crop_size() const;
  inline void clear_crop_size();
  static const int kCropSizeFieldNumber = 3;
  inline ::google::protobuf::uint32 crop_size() const;
  inline void set_crop_size(::google::protobuf::uint32 value);

  // optional string mean_file = 4;
  inline bool has_mean_file() const;
  inline void clear_mean_file();
  static const int kMeanFileFieldNumber = 4;
  inline const ::std::string& mean_file() const;
  inline void set_mean_file(const ::std::string& value);
  inline void set_mean_file(const char* value);
  inline void set_mean_file(const char* value, size_t size);
  inline ::std::string* mutable_mean_file();
  inline ::std::string* release_mean_file();
  inline void set_allocated_mean_file(::std::string* mean_file);

  // repeated float mean_value = 5;
  inline int mean_value_size() const;
  inline void clear_mean_value();
  static const int kMeanValueFieldNumber = 5;
  inline float mean_value(int index) const;
  inline void set_mean_value(int index, float value);
  inline void add_mean_value(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      mean_value() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_mean_value();

  // @@protoc_insertion_point(class_scope:caffe.TransformationParameter)
 private:
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_mirror();
  inline void clear_has_mirror();
  inline void set_has_crop_size();
  inline void clear_has_crop_size();
  inline void set_has_mean_file();
  inline void clear_has_mean_file();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float scale_;
  bool mirror_;
  ::std::string* mean_file_;
  ::google::protobuf::RepeatedField< float > mean_value_;
  ::google::protobuf::uint32 crop_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static TransformationParameter* default_instance_;
};
// -------------------------------------------------------------------

class LossParameter : public ::google::protobuf::Message {
 public:
  LossParameter();
  virtual ~LossParameter();

  LossParameter(const LossParameter& from);

  inline LossParameter& operator=(const LossParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LossParameter& default_instance();

  void Swap(LossParameter* other);

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

  LossParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LossParameter& from);
  void MergeFrom(const LossParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional int32 ignore_label = 1;
  inline bool has_ignore_label() const;
  inline void clear_ignore_label();
  static const int kIgnoreLabelFieldNumber = 1;
  inline ::google::protobuf::int32 ignore_label() const;
  inline void set_ignore_label(::google::protobuf::int32 value);

  // optional bool normalize = 2 [default = true];
  inline bool has_normalize() const;
  inline void clear_normalize();
  static const int kNormalizeFieldNumber = 2;
  inline bool normalize() const;
  inline void set_normalize(bool value);

  // @@protoc_insertion_point(class_scope:caffe.LossParameter)
 private:
  inline void set_has_ignore_label();
  inline void clear_has_ignore_label();
  inline void set_has_normalize();
  inline void clear_has_normalize();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 ignore_label_;
  bool normalize_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static LossParameter* default_instance_;
};
// -------------------------------------------------------------------

class AccuracyParameter : public ::google::protobuf::Message {
 public:
  AccuracyParameter();
  virtual ~AccuracyParameter();

  AccuracyParameter(const AccuracyParameter& from);

  inline AccuracyParameter& operator=(const AccuracyParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AccuracyParameter& default_instance();

  void Swap(AccuracyParameter* other);

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

  AccuracyParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AccuracyParameter& from);
  void MergeFrom(const AccuracyParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional uint32 top_k = 1 [default = 1];
  inline bool has_top_k() const;
  inline void clear_top_k();
  static const int kTopKFieldNumber = 1;
  inline ::google::protobuf::uint32 top_k() const;
  inline void set_top_k(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:caffe.AccuracyParameter)
 private:
  inline void set_has_top_k();
  inline void clear_has_top_k();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 top_k_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static AccuracyParameter* default_instance_;
};
// -------------------------------------------------------------------

class ArgMaxParameter : public ::google::protobuf::Message {
 public:
  ArgMaxParameter();
  virtual ~ArgMaxParameter();

  ArgMaxParameter(const ArgMaxParameter& from);

  inline ArgMaxParameter& operator=(const ArgMaxParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ArgMaxParameter& default_instance();

  void Swap(ArgMaxParameter* other);

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

  ArgMaxParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ArgMaxParameter& from);
  void MergeFrom(const ArgMaxParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional bool out_max_val = 1 [default = false];
  inline bool has_out_max_val() const;
  inline void clear_out_max_val();
  static const int kOutMaxValFieldNumber = 1;
  inline bool out_max_val() const;
  inline void set_out_max_val(bool value);

  // optional uint32 top_k = 2 [default = 1];
  inline bool has_top_k() const;
  inline void clear_top_k();
  static const int kTopKFieldNumber = 2;
  inline ::google::protobuf::uint32 top_k() const;
  inline void set_top_k(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:caffe.ArgMaxParameter)
 private:
  inline void set_has_out_max_val();
  inline void clear_has_out_max_val();
  inline void set_has_top_k();
  inline void clear_has_top_k();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool out_max_val_;
  ::google::protobuf::uint32 top_k_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ArgMaxParameter* default_instance_;
};
// -------------------------------------------------------------------

class ConcatParameter : public ::google::protobuf::Message {
 public:
  ConcatParameter();
  virtual ~ConcatParameter();

  ConcatParameter(const ConcatParameter& from);

  inline ConcatParameter& operator=(const ConcatParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ConcatParameter& default_instance();

  void Swap(ConcatParameter* other);

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

  ConcatParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ConcatParameter& from);
  void MergeFrom(const ConcatParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional uint32 concat_dim = 1 [default = 1];
  inline bool has_concat_dim() const;
  inline void clear_concat_dim();
  static const int kConcatDimFieldNumber = 1;
  inline ::google::protobuf::uint32 concat_dim() const;
  inline void set_concat_dim(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:caffe.ConcatParameter)
 private:
  inline void set_has_concat_dim();
  inline void clear_has_concat_dim();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 concat_dim_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ConcatParameter* default_instance_;
};
// -------------------------------------------------------------------

class ContrastiveLossParameter : public ::google::protobuf::Message {
 public:
  ContrastiveLossParameter();
  virtual ~ContrastiveLossParameter();

  ContrastiveLossParameter(const ContrastiveLossParameter& from);

  inline ContrastiveLossParameter& operator=(const ContrastiveLossParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ContrastiveLossParameter& default_instance();

  void Swap(ContrastiveLossParameter* other);

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

  ContrastiveLossParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ContrastiveLossParameter& from);
  void MergeFrom(const ContrastiveLossParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional float margin = 1 [default = 1];
  inline bool has_margin() const;
  inline void clear_margin();
  static const int kMarginFieldNumber = 1;
  inline float margin() const;
  inline void set_margin(float value);

  // @@protoc_insertion_point(class_scope:caffe.ContrastiveLossParameter)
 private:
  inline void set_has_margin();
  inline void clear_has_margin();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float margin_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ContrastiveLossParameter* default_instance_;
};
// -------------------------------------------------------------------

class ConvolutionParameter : public ::google::protobuf::Message {
 public:
  ConvolutionParameter();
  virtual ~ConvolutionParameter();

  ConvolutionParameter(const ConvolutionParameter& from);

  inline ConvolutionParameter& operator=(const ConvolutionParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ConvolutionParameter& default_instance();

  void Swap(ConvolutionParameter* other);

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

  ConvolutionParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ConvolutionParameter& from);
  void MergeFrom(const ConvolutionParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef ConvolutionParameter_Engine Engine;
  static const Engine DEFAULT = ConvolutionParameter_Engine_DEFAULT;
  static const Engine CAFFE = ConvolutionParameter_Engine_CAFFE;
  static const Engine CUDNN = ConvolutionParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return ConvolutionParameter_Engine_IsValid(value);
  }
  static const Engine Engine_MIN =
    ConvolutionParameter_Engine_Engine_MIN;
  static const Engine Engine_MAX =
    ConvolutionParameter_Engine_Engine_MAX;
  static const int Engine_ARRAYSIZE =
    ConvolutionParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Engine_descriptor() {
    return ConvolutionParameter_Engine_descriptor();
  }
  static inline const ::std::string& Engine_Name(Engine value) {
    return ConvolutionParameter_Engine_Name(value);
  }
  static inline bool Engine_Parse(const ::std::string& name,
      Engine* value) {
    return ConvolutionParameter_Engine_Parse(name, value);
  }

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

  // optional uint32 num_output = 1;
  inline bool has_num_output() const;
  inline void clear_num_output();
  static const int kNumOutputFieldNumber = 1;
  inline ::google::protobuf::uint32 num_output() const;
  inline void set_num_output(::google::protobuf::uint32 value);

  // optional bool bias_term = 2 [default = true];
  inline bool has_bias_term() const;
  inline void clear_bias_term();
  static const int kBiasTermFieldNumber = 2;
  inline bool bias_term() const;
  inline void set_bias_term(bool value);

  // optional uint32 pad = 3 [default = 0];
  inline bool has_pad() const;
  inline void clear_pad();
  static const int kPadFieldNumber = 3;
  inline ::google::protobuf::uint32 pad() const;
  inline void set_pad(::google::protobuf::uint32 value);

  // optional uint32 pad_h = 9 [default = 0];
  inline bool has_pad_h() const;
  inline void clear_pad_h();
  static const int kPadHFieldNumber = 9;
  inline ::google::protobuf::uint32 pad_h() const;
  inline void set_pad_h(::google::protobuf::uint32 value);

  // optional uint32 pad_w = 10 [default = 0];
  inline bool has_pad_w() const;
  inline void clear_pad_w();
  static const int kPadWFieldNumber = 10;
  inline ::google::protobuf::uint32 pad_w() const;
  inline void set_pad_w(::google::protobuf::uint32 value);

  // optional uint32 kernel_size = 4;
  inline bool has_kernel_size() const;
  inline void clear_kernel_size();
  static const int kKernelSizeFieldNumber = 4;
  inline ::google::protobuf::uint32 kernel_size() const;
  inline void set_kernel_size(::google::protobuf::uint32 value);

  // optional uint32 kernel_h = 11;
  inline bool has_kernel_h() const;
  inline void clear_kernel_h();
  static const int kKernelHFieldNumber = 11;
  inline ::google::protobuf::uint32 kernel_h() const;
  inline void set_kernel_h(::google::protobuf::uint32 value);

  // optional uint32 kernel_w = 12;
  inline bool has_kernel_w() const;
  inline void clear_kernel_w();
  static const int kKernelWFieldNumber = 12;
  inline ::google::protobuf::uint32 kernel_w() const;
  inline void set_kernel_w(::google::protobuf::uint32 value);

  // optional uint32 group = 5 [default = 1];
  inline bool has_group() const;
  inline void clear_group();
  static const int kGroupFieldNumber = 5;
  inline ::google::protobuf::uint32 group() const;
  inline void set_group(::google::protobuf::uint32 value);

  // optional uint32 stride = 6 [default = 1];
  inline bool has_stride() const;
  inline void clear_stride();
  static const int kStrideFieldNumber = 6;
  inline ::google::protobuf::uint32 stride() const;
  inline void set_stride(::google::protobuf::uint32 value);

  // optional uint32 stride_h = 13;
  inline bool has_stride_h() const;
  inline void clear_stride_h();
  static const int kStrideHFieldNumber = 13;
  inline ::google::protobuf::uint32 stride_h() const;
  inline void set_stride_h(::google::protobuf::uint32 value);

  // optional uint32 stride_w = 14;
  inline bool has_stride_w() const;
  inline void clear_stride_w();
  static const int kStrideWFieldNumber = 14;
  inline ::google::protobuf::uint32 stride_w() const;
  inline void set_stride_w(::google::protobuf::uint32 value);

  // optional .caffe.FillerParameter weight_filler = 7;
  inline bool has_weight_filler() const;
  inline void clear_weight_filler();
  static const int kWeightFillerFieldNumber = 7;
  inline const ::caffe::FillerParameter& weight_filler() const;
  inline ::caffe::FillerParameter* mutable_weight_filler();
  inline ::caffe::FillerParameter* release_weight_filler();
  inline void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);

  // optional .caffe.FillerParameter bias_filler = 8;
  inline bool has_bias_filler() const;
  inline void clear_bias_filler();
  static const int kBiasFillerFieldNumber = 8;
  inline const ::caffe::FillerParameter& bias_filler() const;
  inline ::caffe::FillerParameter* mutable_bias_filler();
  inline ::caffe::FillerParameter* release_bias_filler();
  inline void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);

  // optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 15;
  inline ::caffe::ConvolutionParameter_Engine engine() const;
  inline void set_engine(::caffe::ConvolutionParameter_Engine value);

  // @@protoc_insertion_point(class_scope:caffe.ConvolutionParameter)
 private:
  inline void set_has_num_output();
  inline void clear_has_num_output();
  inline void set_has_bias_term();
  inline void clear_has_bias_term();
  inline void set_has_pad();
  inline void clear_has_pad();
  inline void set_has_pad_h();
  inline void clear_has_pad_h();
  inline void set_has_pad_w();
  inline void clear_has_pad_w();
  inline void set_has_kernel_size();
  inline void clear_has_kernel_size();
  inline void set_has_kernel_h();
  inline void clear_has_kernel_h();
  inline void set_has_kernel_w();
  inline void clear_has_kernel_w();
  inline void set_has_group();
  inline void clear_has_group();
  inline void set_has_stride();
  inline void clear_has_stride();
  inline void set_has_stride_h();
  inline void clear_has_stride_h();
  inline void set_has_stride_w();
  inline void clear_has_stride_w();
  inline void set_has_weight_filler();
  inline void clear_has_weight_filler();
  inline void set_has_bias_filler();
  inline void clear_has_bias_filler();
  inline void set_has_engine();
  inline void clear_has_engine();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 num_output_;
  bool bias_term_;
  ::google::protobuf::uint32 pad_;
  ::google::protobuf::uint32 pad_h_;
  ::google::protobuf::uint32 pad_w_;
  ::google::protobuf::uint32 kernel_size_;
  ::google::protobuf::uint32 kernel_h_;
  ::google::protobuf::uint32 kernel_w_;
  ::google::protobuf::uint32 group_;
  ::google::protobuf::uint32 stride_;
  ::google::protobuf::uint32 stride_h_;
  ::google::protobuf::uint32 stride_w_;
  ::caffe::FillerParameter* weight_filler_;
  ::caffe::FillerParameter* bias_filler_;
  int engine_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(15 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ConvolutionParameter* default_instance_;
};
// -------------------------------------------------------------------

class MultiStageMeanfieldParameter : public ::google::protobuf::Message {
 public:
  MultiStageMeanfieldParameter();
  virtual ~MultiStageMeanfieldParameter();

  MultiStageMeanfieldParameter(const MultiStageMeanfieldParameter& from);

  inline MultiStageMeanfieldParameter& operator=(const MultiStageMeanfieldParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const MultiStageMeanfieldParameter& default_instance();

  void Swap(MultiStageMeanfieldParameter* other);

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

  MultiStageMeanfieldParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MultiStageMeanfieldParameter& from);
  void MergeFrom(const MultiStageMeanfieldParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef MultiStageMeanfieldParameter_Mode Mode;
  static const Mode POTTS = MultiStageMeanfieldParameter_Mode_POTTS;
  static inline bool Mode_IsValid(int value) {
    return MultiStageMeanfieldParameter_Mode_IsValid(value);
  }
  static const Mode Mode_MIN =
    MultiStageMeanfieldParameter_Mode_Mode_MIN;
  static const Mode Mode_MAX =
    MultiStageMeanfieldParameter_Mode_Mode_MAX;
  static const int Mode_ARRAYSIZE =
    MultiStageMeanfieldParameter_Mode_Mode_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Mode_descriptor() {
    return MultiStageMeanfieldParameter_Mode_descriptor();
  }
  static inline const ::std::string& Mode_Name(Mode value) {
    return MultiStageMeanfieldParameter_Mode_Name(value);
  }
  static inline bool Mode_Parse(const ::std::string& name,
      Mode* value) {
    return MultiStageMeanfieldParameter_Mode_Parse(name, value);
  }

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

  // optional .caffe.MultiStageMeanfieldParameter.Mode compatibility_mode = 1 [default = POTTS];
  inline bool has_compatibility_mode() const;
  inline void clear_compatibility_mode();
  static const int kCompatibilityModeFieldNumber = 1;
  inline ::caffe::MultiStageMeanfieldParameter_Mode compatibility_mode() const;
  inline void set_compatibility_mode(::caffe::MultiStageMeanfieldParameter_Mode value);

  // optional float threshold = 2;
  inline bool has_threshold() const;
  inline void clear_threshold();
  static const int kThresholdFieldNumber = 2;
  inline float threshold() const;
  inline void set_threshold(float value);

  // required float theta_alpha = 3 [default = 10];
  inline bool has_theta_alpha() const;
  inline void clear_theta_alpha();
  static const int kThetaAlphaFieldNumber = 3;
  inline float theta_alpha() const;
  inline void set_theta_alpha(float value);

  // required float theta_beta = 4 [default = 10];
  inline bool has_theta_beta() const;
  inline void clear_theta_beta();
  static const int kThetaBetaFieldNumber = 4;
  inline float theta_beta() const;
  inline void set_theta_beta(float value);

  // required float theta_gamma = 5 [default = 10];
  inline bool has_theta_gamma() const;
  inline void clear_theta_gamma();
  static const int kThetaGammaFieldNumber = 5;
  inline float theta_gamma() const;
  inline void set_theta_gamma(float value);

  // required uint32 num_iterations = 6 [default = 1];
  inline bool has_num_iterations() const;
  inline void clear_num_iterations();
  static const int kNumIterationsFieldNumber = 6;
  inline ::google::protobuf::uint32 num_iterations() const;
  inline void set_num_iterations(::google::protobuf::uint32 value);

  // optional float spatial_filter_weight = 7 [default = 1];
  inline bool has_spatial_filter_weight() const;
  inline void clear_spatial_filter_weight();
  static const int kSpatialFilterWeightFieldNumber = 7;
  inline float spatial_filter_weight() const;
  inline void set_spatial_filter_weight(float value);

  // optional float bilateral_filter_weight = 8 [default = 1];
  inline bool has_bilateral_filter_weight() const;
  inline void clear_bilateral_filter_weight();
  static const int kBilateralFilterWeightFieldNumber = 8;
  inline float bilateral_filter_weight() const;
  inline void set_bilateral_filter_weight(float value);

  // optional float forced_spatial_filter_weight = 9;
  inline bool has_forced_spatial_filter_weight() const;
  inline void clear_forced_spatial_filter_weight();
  static const int kForcedSpatialFilterWeightFieldNumber = 9;
  inline float forced_spatial_filter_weight() const;
  inline void set_forced_spatial_filter_weight(float value);

  // optional float forced_bilateral_filter_weight = 10;
  inline bool has_forced_bilateral_filter_weight() const;
  inline void clear_forced_bilateral_filter_weight();
  static const int kForcedBilateralFilterWeightFieldNumber = 10;
  inline float forced_bilateral_filter_weight() const;
  inline void set_forced_bilateral_filter_weight(float value);

  // @@protoc_insertion_point(class_scope:caffe.MultiStageMeanfieldParameter)
 private:
  inline void set_has_compatibility_mode();
  inline void clear_has_compatibility_mode();
  inline void set_has_threshold();
  inline void clear_has_threshold();
  inline void set_has_theta_alpha();
  inline void clear_has_theta_alpha();
  inline void set_has_theta_beta();
  inline void clear_has_theta_beta();
  inline void set_has_theta_gamma();
  inline void clear_has_theta_gamma();
  inline void set_has_num_iterations();
  inline void clear_has_num_iterations();
  inline void set_has_spatial_filter_weight();
  inline void clear_has_spatial_filter_weight();
  inline void set_has_bilateral_filter_weight();
  inline void clear_has_bilateral_filter_weight();
  inline void set_has_forced_spatial_filter_weight();
  inline void clear_has_forced_spatial_filter_weight();
  inline void set_has_forced_bilateral_filter_weight();
  inline void clear_has_forced_bilateral_filter_weight();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int compatibility_mode_;
  float threshold_;
  float theta_alpha_;
  float theta_beta_;
  float theta_gamma_;
  ::google::protobuf::uint32 num_iterations_;
  float spatial_filter_weight_;
  float bilateral_filter_weight_;
  float forced_spatial_filter_weight_;
  float forced_bilateral_filter_weight_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(10 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static MultiStageMeanfieldParameter* default_instance_;
};
// -------------------------------------------------------------------

class DataParameter : public ::google::protobuf::Message {
 public:
  DataParameter();
  virtual ~DataParameter();

  DataParameter(const DataParameter& from);

  inline DataParameter& operator=(const DataParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DataParameter& default_instance();

  void Swap(DataParameter* other);

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

  DataParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DataParameter& from);
  void MergeFrom(const DataParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef DataParameter_DB DB;
  static const DB LEVELDB = DataParameter_DB_LEVELDB;
  static const DB LMDB = DataParameter_DB_LMDB;
  static inline bool DB_IsValid(int value) {
    return DataParameter_DB_IsValid(value);
  }
  static const DB DB_MIN =
    DataParameter_DB_DB_MIN;
  static const DB DB_MAX =
    DataParameter_DB_DB_MAX;
  static const int DB_ARRAYSIZE =
    DataParameter_DB_DB_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  DB_descriptor() {
    return DataParameter_DB_descriptor();
  }
  static inline const ::std::string& DB_Name(DB value) {
    return DataParameter_DB_Name(value);
  }
  static inline bool DB_Parse(const ::std::string& name,
      DB* value) {
    return DataParameter_DB_Parse(name, value);
  }

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

  // optional string source = 1;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 1;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // optional uint32 batch_size = 4;
  inline bool has_batch_size() const;
  inline void clear_batch_size();
  static const int kBatchSizeFieldNumber = 4;
  inline ::google::protobuf::uint32 batch_size() const;
  inline void set_batch_size(::google::protobuf::uint32 value);

  // optional uint32 rand_skip = 7 [default = 0];
  inline bool has_rand_skip() const;
  inline void clear_rand_skip();
  static const int kRandSkipFieldNumber = 7;
  inline ::google::protobuf::uint32 rand_skip() const;
  inline void set_rand_skip(::google::protobuf::uint32 value);

  // optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB];
  inline bool has_backend() const;
  inline void clear_backend();
  static const int kBackendFieldNumber = 8;
  inline ::caffe::DataParameter_DB backend() const;
  inline void set_backend(::caffe::DataParameter_DB value);

  // optional float scale = 2 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline float scale() const;
  inline void set_scale(float value);

  // optional string mean_file = 3;
  inline bool has_mean_file() const;
  inline void clear_mean_file();
  static const int kMeanFileFieldNumber = 3;
  inline const ::std::string& mean_file() const;
  inline void set_mean_file(const ::std::string& value);
  inline void set_mean_file(const char* value);
  inline void set_mean_file(const char* value, size_t size);
  inline ::std::string* mutable_mean_file();
  inline ::std::string* release_mean_file();
  inline void set_allocated_mean_file(::std::string* mean_file);

  // optional uint32 crop_size = 5 [default = 0];
  inline bool has_crop_size() const;
  inline void clear_crop_size();
  static const int kCropSizeFieldNumber = 5;
  inline ::google::protobuf::uint32 crop_size() const;
  inline void set_crop_size(::google::protobuf::uint32 value);

  // optional bool mirror = 6 [default = false];
  inline bool has_mirror() const;
  inline void clear_mirror();
  static const int kMirrorFieldNumber = 6;
  inline bool mirror() const;
  inline void set_mirror(bool value);

  // @@protoc_insertion_point(class_scope:caffe.DataParameter)
 private:
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_batch_size();
  inline void clear_has_batch_size();
  inline void set_has_rand_skip();
  inline void clear_has_rand_skip();
  inline void set_has_backend();
  inline void clear_has_backend();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_mean_file();
  inline void clear_has_mean_file();
  inline void set_has_crop_size();
  inline void clear_has_crop_size();
  inline void set_has_mirror();
  inline void clear_has_mirror();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* source_;
  ::google::protobuf::uint32 batch_size_;
  ::google::protobuf::uint32 rand_skip_;
  int backend_;
  float scale_;
  ::std::string* mean_file_;
  ::google::protobuf::uint32 crop_size_;
  bool mirror_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static DataParameter* default_instance_;
};
// -------------------------------------------------------------------

class DropoutParameter : public ::google::protobuf::Message {
 public:
  DropoutParameter();
  virtual ~DropoutParameter();

  DropoutParameter(const DropoutParameter& from);

  inline DropoutParameter& operator=(const DropoutParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DropoutParameter& default_instance();

  void Swap(DropoutParameter* other);

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

  DropoutParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DropoutParameter& from);
  void MergeFrom(const DropoutParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional float dropout_ratio = 1 [default = 0.5];
  inline bool has_dropout_ratio() const;
  inline void clear_dropout_ratio();
  static const int kDropoutRatioFieldNumber = 1;
  inline float dropout_ratio() const;
  inline void set_dropout_ratio(float value);

  // @@protoc_insertion_point(class_scope:caffe.DropoutParameter)
 private:
  inline void set_has_dropout_ratio();
  inline void clear_has_dropout_ratio();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float dropout_ratio_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static DropoutParameter* default_instance_;
};
// -------------------------------------------------------------------

class DummyDataParameter : public ::google::protobuf::Message {
 public:
  DummyDataParameter();
  virtual ~DummyDataParameter();

  DummyDataParameter(const DummyDataParameter& from);

  inline DummyDataParameter& operator=(const DummyDataParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DummyDataParameter& default_instance();

  void Swap(DummyDataParameter* other);

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

  DummyDataParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DummyDataParameter& from);
  void MergeFrom(const DummyDataParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .caffe.FillerParameter data_filler = 1;
  inline int data_filler_size() const;
  inline void clear_data_filler();
  static const int kDataFillerFieldNumber = 1;
  inline const ::caffe::FillerParameter& data_filler(int index) const;
  inline ::caffe::FillerParameter* mutable_data_filler(int index);
  inline ::caffe::FillerParameter* add_data_filler();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >&
      data_filler() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >*
      mutable_data_filler();

  // repeated uint32 num = 2;
  inline int num_size() const;
  inline void clear_num();
  static const int kNumFieldNumber = 2;
  inline ::google::protobuf::uint32 num(int index) const;
  inline void set_num(int index, ::google::protobuf::uint32 value);
  inline void add_num(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      num() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_num();

  // repeated uint32 channels = 3;
  inline int channels_size() const;
  inline void clear_channels();
  static const int kChannelsFieldNumber = 3;
  inline ::google::protobuf::uint32 channels(int index) const;
  inline void set_channels(int index, ::google::protobuf::uint32 value);
  inline void add_channels(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      channels() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_channels();

  // repeated uint32 height = 4;
  inline int height_size() const;
  inline void clear_height();
  static const int kHeightFieldNumber = 4;
  inline ::google::protobuf::uint32 height(int index) const;
  inline void set_height(int index, ::google::protobuf::uint32 value);
  inline void add_height(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      height() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_height();

  // repeated uint32 width = 5;
  inline int width_size() const;
  inline void clear_width();
  static const int kWidthFieldNumber = 5;
  inline ::google::protobuf::uint32 width(int index) const;
  inline void set_width(int index, ::google::protobuf::uint32 value);
  inline void add_width(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      width() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_width();

  // @@protoc_insertion_point(class_scope:caffe.DummyDataParameter)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter > data_filler_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > num_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > channels_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > height_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > width_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static DummyDataParameter* default_instance_;
};
// -------------------------------------------------------------------

class EltwiseParameter : public ::google::protobuf::Message {
 public:
  EltwiseParameter();
  virtual ~EltwiseParameter();

  EltwiseParameter(const EltwiseParameter& from);

  inline EltwiseParameter& operator=(const EltwiseParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const EltwiseParameter& default_instance();

  void Swap(EltwiseParameter* other);

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

  EltwiseParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const EltwiseParameter& from);
  void MergeFrom(const EltwiseParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef EltwiseParameter_EltwiseOp EltwiseOp;
  static const EltwiseOp PROD = EltwiseParameter_EltwiseOp_PROD;
  static const EltwiseOp SUM = EltwiseParameter_EltwiseOp_SUM;
  static const EltwiseOp MAX = EltwiseParameter_EltwiseOp_MAX;
  static inline bool EltwiseOp_IsValid(int value) {
    return EltwiseParameter_EltwiseOp_IsValid(value);
  }
  static const EltwiseOp EltwiseOp_MIN =
    EltwiseParameter_EltwiseOp_EltwiseOp_MIN;
  static const EltwiseOp EltwiseOp_MAX =
    EltwiseParameter_EltwiseOp_EltwiseOp_MAX;
  static const int EltwiseOp_ARRAYSIZE =
    EltwiseParameter_EltwiseOp_EltwiseOp_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  EltwiseOp_descriptor() {
    return EltwiseParameter_EltwiseOp_descriptor();
  }
  static inline const ::std::string& EltwiseOp_Name(EltwiseOp value) {
    return EltwiseParameter_EltwiseOp_Name(value);
  }
  static inline bool EltwiseOp_Parse(const ::std::string& name,
      EltwiseOp* value) {
    return EltwiseParameter_EltwiseOp_Parse(name, value);
  }

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

  // optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
  inline bool has_operation() const;
  inline void clear_operation();
  static const int kOperationFieldNumber = 1;
  inline ::caffe::EltwiseParameter_EltwiseOp operation() const;
  inline void set_operation(::caffe::EltwiseParameter_EltwiseOp value);

  // repeated float coeff = 2;
  inline int coeff_size() const;
  inline void clear_coeff();
  static const int kCoeffFieldNumber = 2;
  inline float coeff(int index) const;
  inline void set_coeff(int index, float value);
  inline void add_coeff(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      coeff() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_coeff();

  // optional bool stable_prod_grad = 3 [default = true];
  inline bool has_stable_prod_grad() const;
  inline void clear_stable_prod_grad();
  static const int kStableProdGradFieldNumber = 3;
  inline bool stable_prod_grad() const;
  inline void set_stable_prod_grad(bool value);

  // @@protoc_insertion_point(class_scope:caffe.EltwiseParameter)
 private:
  inline void set_has_operation();
  inline void clear_has_operation();
  inline void set_has_stable_prod_grad();
  inline void clear_has_stable_prod_grad();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< float > coeff_;
  int operation_;
  bool stable_prod_grad_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static EltwiseParameter* default_instance_;
};
// -------------------------------------------------------------------

class ExpParameter : public ::google::protobuf::Message {
 public:
  ExpParameter();
  virtual ~ExpParameter();

  ExpParameter(const ExpParameter& from);

  inline ExpParameter& operator=(const ExpParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ExpParameter& default_instance();

  void Swap(ExpParameter* other);

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

  ExpParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ExpParameter& from);
  void MergeFrom(const ExpParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional float base = 1 [default = -1];
  inline bool has_base() const;
  inline void clear_base();
  static const int kBaseFieldNumber = 1;
  inline float base() const;
  inline void set_base(float value);

  // optional float scale = 2 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline float scale() const;
  inline void set_scale(float value);

  // optional float shift = 3 [default = 0];
  inline bool has_shift() const;
  inline void clear_shift();
  static const int kShiftFieldNumber = 3;
  inline float shift() const;
  inline void set_shift(float value);

  // @@protoc_insertion_point(class_scope:caffe.ExpParameter)
 private:
  inline void set_has_base();
  inline void clear_has_base();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_shift();
  inline void clear_has_shift();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float base_;
  float scale_;
  float shift_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ExpParameter* default_instance_;
};
// -------------------------------------------------------------------

class HDF5DataParameter : public ::google::protobuf::Message {
 public:
  HDF5DataParameter();
  virtual ~HDF5DataParameter();

  HDF5DataParameter(const HDF5DataParameter& from);

  inline HDF5DataParameter& operator=(const HDF5DataParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HDF5DataParameter& default_instance();

  void Swap(HDF5DataParameter* other);

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

  HDF5DataParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HDF5DataParameter& from);
  void MergeFrom(const HDF5DataParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string source = 1;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 1;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // optional uint32 batch_size = 2;
  inline bool has_batch_size() const;
  inline void clear_batch_size();
  static const int kBatchSizeFieldNumber = 2;
  inline ::google::protobuf::uint32 batch_size() const;
  inline void set_batch_size(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:caffe.HDF5DataParameter)
 private:
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_batch_size();
  inline void clear_has_batch_size();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* source_;
  ::google::protobuf::uint32 batch_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static HDF5DataParameter* default_instance_;
};
// -------------------------------------------------------------------

class HDF5OutputParameter : public ::google::protobuf::Message {
 public:
  HDF5OutputParameter();
  virtual ~HDF5OutputParameter();

  HDF5OutputParameter(const HDF5OutputParameter& from);

  inline HDF5OutputParameter& operator=(const HDF5OutputParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HDF5OutputParameter& default_instance();

  void Swap(HDF5OutputParameter* other);

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

  HDF5OutputParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HDF5OutputParameter& from);
  void MergeFrom(const HDF5OutputParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string file_name = 1;
  inline bool has_file_name() const;
  inline void clear_file_name();
  static const int kFileNameFieldNumber = 1;
  inline const ::std::string& file_name() const;
  inline void set_file_name(const ::std::string& value);
  inline void set_file_name(const char* value);
  inline void set_file_name(const char* value, size_t size);
  inline ::std::string* mutable_file_name();
  inline ::std::string* release_file_name();
  inline void set_allocated_file_name(::std::string* file_name);

  // @@protoc_insertion_point(class_scope:caffe.HDF5OutputParameter)
 private:
  inline void set_has_file_name();
  inline void clear_has_file_name();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* file_name_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static HDF5OutputParameter* default_instance_;
};
// -------------------------------------------------------------------

class HingeLossParameter : public ::google::protobuf::Message {
 public:
  HingeLossParameter();
  virtual ~HingeLossParameter();

  HingeLossParameter(const HingeLossParameter& from);

  inline HingeLossParameter& operator=(const HingeLossParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HingeLossParameter& default_instance();

  void Swap(HingeLossParameter* other);

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

  HingeLossParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HingeLossParameter& from);
  void MergeFrom(const HingeLossParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef HingeLossParameter_Norm Norm;
  static const Norm L1 = HingeLossParameter_Norm_L1;
  static const Norm L2 = HingeLossParameter_Norm_L2;
  static inline bool Norm_IsValid(int value) {
    return HingeLossParameter_Norm_IsValid(value);
  }
  static const Norm Norm_MIN =
    HingeLossParameter_Norm_Norm_MIN;
  static const Norm Norm_MAX =
    HingeLossParameter_Norm_Norm_MAX;
  static const int Norm_ARRAYSIZE =
    HingeLossParameter_Norm_Norm_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Norm_descriptor() {
    return HingeLossParameter_Norm_descriptor();
  }
  static inline const ::std::string& Norm_Name(Norm value) {
    return HingeLossParameter_Norm_Name(value);
  }
  static inline bool Norm_Parse(const ::std::string& name,
      Norm* value) {
    return HingeLossParameter_Norm_Parse(name, value);
  }

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

  // optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1];
  inline bool has_norm() const;
  inline void clear_norm();
  static const int kNormFieldNumber = 1;
  inline ::caffe::HingeLossParameter_Norm norm() const;
  inline void set_norm(::caffe::HingeLossParameter_Norm value);

  // @@protoc_insertion_point(class_scope:caffe.HingeLossParameter)
 private:
  inline void set_has_norm();
  inline void clear_has_norm();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int norm_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static HingeLossParameter* default_instance_;
};
// -------------------------------------------------------------------

class ImageDataParameter : public ::google::protobuf::Message {
 public:
  ImageDataParameter();
  virtual ~ImageDataParameter();

  ImageDataParameter(const ImageDataParameter& from);

  inline ImageDataParameter& operator=(const ImageDataParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ImageDataParameter& default_instance();

  void Swap(ImageDataParameter* other);

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

  ImageDataParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ImageDataParameter& from);
  void MergeFrom(const ImageDataParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string source = 1;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 1;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // optional uint32 batch_size = 4;
  inline bool has_batch_size() const;
  inline void clear_batch_size();
  static const int kBatchSizeFieldNumber = 4;
  inline ::google::protobuf::uint32 batch_size() const;
  inline void set_batch_size(::google::protobuf::uint32 value);

  // optional uint32 rand_skip = 7 [default = 0];
  inline bool has_rand_skip() const;
  inline void clear_rand_skip();
  static const int kRandSkipFieldNumber = 7;
  inline ::google::protobuf::uint32 rand_skip() const;
  inline void set_rand_skip(::google::protobuf::uint32 value);

  // optional bool shuffle = 8 [default = false];
  inline bool has_shuffle() const;
  inline void clear_shuffle();
  static const int kShuffleFieldNumber = 8;
  inline bool shuffle() const;
  inline void set_shuffle(bool value);

  // optional uint32 new_height = 9 [default = 0];
  inline bool has_new_height() const;
  inline void clear_new_height();
  static const int kNewHeightFieldNumber = 9;
  inline ::google::protobuf::uint32 new_height() const;
  inline void set_new_height(::google::protobuf::uint32 value);

  // optional uint32 new_width = 10 [default = 0];
  inline bool has_new_width() const;
  inline void clear_new_width();
  static const int kNewWidthFieldNumber = 10;
  inline ::google::protobuf::uint32 new_width() const;
  inline void set_new_width(::google::protobuf::uint32 value);

  // optional bool is_color = 11 [default = true];
  inline bool has_is_color() const;
  inline void clear_is_color();
  static const int kIsColorFieldNumber = 11;
  inline bool is_color() const;
  inline void set_is_color(bool value);

  // optional float scale = 2 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline float scale() const;
  inline void set_scale(float value);

  // optional string mean_file = 3;
  inline bool has_mean_file() const;
  inline void clear_mean_file();
  static const int kMeanFileFieldNumber = 3;
  inline const ::std::string& mean_file() const;
  inline void set_mean_file(const ::std::string& value);
  inline void set_mean_file(const char* value);
  inline void set_mean_file(const char* value, size_t size);
  inline ::std::string* mutable_mean_file();
  inline ::std::string* release_mean_file();
  inline void set_allocated_mean_file(::std::string* mean_file);

  // optional uint32 crop_size = 5 [default = 0];
  inline bool has_crop_size() const;
  inline void clear_crop_size();
  static const int kCropSizeFieldNumber = 5;
  inline ::google::protobuf::uint32 crop_size() const;
  inline void set_crop_size(::google::protobuf::uint32 value);

  // optional bool mirror = 6 [default = false];
  inline bool has_mirror() const;
  inline void clear_mirror();
  static const int kMirrorFieldNumber = 6;
  inline bool mirror() const;
  inline void set_mirror(bool value);

  // optional string root_folder = 12 [default = ""];
  inline bool has_root_folder() const;
  inline void clear_root_folder();
  static const int kRootFolderFieldNumber = 12;
  inline const ::std::string& root_folder() const;
  inline void set_root_folder(const ::std::string& value);
  inline void set_root_folder(const char* value);
  inline void set_root_folder(const char* value, size_t size);
  inline ::std::string* mutable_root_folder();
  inline ::std::string* release_root_folder();
  inline void set_allocated_root_folder(::std::string* root_folder);

  // @@protoc_insertion_point(class_scope:caffe.ImageDataParameter)
 private:
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_batch_size();
  inline void clear_has_batch_size();
  inline void set_has_rand_skip();
  inline void clear_has_rand_skip();
  inline void set_has_shuffle();
  inline void clear_has_shuffle();
  inline void set_has_new_height();
  inline void clear_has_new_height();
  inline void set_has_new_width();
  inline void clear_has_new_width();
  inline void set_has_is_color();
  inline void clear_has_is_color();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_mean_file();
  inline void clear_has_mean_file();
  inline void set_has_crop_size();
  inline void clear_has_crop_size();
  inline void set_has_mirror();
  inline void clear_has_mirror();
  inline void set_has_root_folder();
  inline void clear_has_root_folder();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* source_;
  ::google::protobuf::uint32 batch_size_;
  ::google::protobuf::uint32 rand_skip_;
  ::google::protobuf::uint32 new_height_;
  ::google::protobuf::uint32 new_width_;
  bool shuffle_;
  bool is_color_;
  bool mirror_;
  float scale_;
  ::std::string* mean_file_;
  ::std::string* root_folder_;
  ::google::protobuf::uint32 crop_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ImageDataParameter* default_instance_;
};
// -------------------------------------------------------------------

class InfogainLossParameter : public ::google::protobuf::Message {
 public:
  InfogainLossParameter();
  virtual ~InfogainLossParameter();

  InfogainLossParameter(const InfogainLossParameter& from);

  inline InfogainLossParameter& operator=(const InfogainLossParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const InfogainLossParameter& default_instance();

  void Swap(InfogainLossParameter* other);

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

  InfogainLossParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const InfogainLossParameter& from);
  void MergeFrom(const InfogainLossParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string source = 1;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 1;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // @@protoc_insertion_point(class_scope:caffe.InfogainLossParameter)
 private:
  inline void set_has_source();
  inline void clear_has_source();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* source_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static InfogainLossParameter* default_instance_;
};
// -------------------------------------------------------------------

class InnerProductParameter : public ::google::protobuf::Message {
 public:
  InnerProductParameter();
  virtual ~InnerProductParameter();

  InnerProductParameter(const InnerProductParameter& from);

  inline InnerProductParameter& operator=(const InnerProductParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const InnerProductParameter& default_instance();

  void Swap(InnerProductParameter* other);

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

  InnerProductParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const InnerProductParameter& from);
  void MergeFrom(const InnerProductParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional uint32 num_output = 1;
  inline bool has_num_output() const;
  inline void clear_num_output();
  static const int kNumOutputFieldNumber = 1;
  inline ::google::protobuf::uint32 num_output() const;
  inline void set_num_output(::google::protobuf::uint32 value);

  // optional bool bias_term = 2 [default = true];
  inline bool has_bias_term() const;
  inline void clear_bias_term();
  static const int kBiasTermFieldNumber = 2;
  inline bool bias_term() const;
  inline void set_bias_term(bool value);

  // optional .caffe.FillerParameter weight_filler = 3;
  inline bool has_weight_filler() const;
  inline void clear_weight_filler();
  static const int kWeightFillerFieldNumber = 3;
  inline const ::caffe::FillerParameter& weight_filler() const;
  inline ::caffe::FillerParameter* mutable_weight_filler();
  inline ::caffe::FillerParameter* release_weight_filler();
  inline void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);

  // optional .caffe.FillerParameter bias_filler = 4;
  inline bool has_bias_filler() const;
  inline void clear_bias_filler();
  static const int kBiasFillerFieldNumber = 4;
  inline const ::caffe::FillerParameter& bias_filler() const;
  inline ::caffe::FillerParameter* mutable_bias_filler();
  inline ::caffe::FillerParameter* release_bias_filler();
  inline void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);

  // @@protoc_insertion_point(class_scope:caffe.InnerProductParameter)
 private:
  inline void set_has_num_output();
  inline void clear_has_num_output();
  inline void set_has_bias_term();
  inline void clear_has_bias_term();
  inline void set_has_weight_filler();
  inline void clear_has_weight_filler();
  inline void set_has_bias_filler();
  inline void clear_has_bias_filler();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 num_output_;
  bool bias_term_;
  ::caffe::FillerParameter* weight_filler_;
  ::caffe::FillerParameter* bias_filler_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static InnerProductParameter* default_instance_;
};
// -------------------------------------------------------------------

class LRNParameter : public ::google::protobuf::Message {
 public:
  LRNParameter();
  virtual ~LRNParameter();

  LRNParameter(const LRNParameter& from);

  inline LRNParameter& operator=(const LRNParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LRNParameter& default_instance();

  void Swap(LRNParameter* other);

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

  LRNParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LRNParameter& from);
  void MergeFrom(const LRNParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef LRNParameter_NormRegion NormRegion;
  static const NormRegion ACROSS_CHANNELS = LRNParameter_NormRegion_ACROSS_CHANNELS;
  static const NormRegion WITHIN_CHANNEL = LRNParameter_NormRegion_WITHIN_CHANNEL;
  static inline bool NormRegion_IsValid(int value) {
    return LRNParameter_NormRegion_IsValid(value);
  }
  static const NormRegion NormRegion_MIN =
    LRNParameter_NormRegion_NormRegion_MIN;
  static const NormRegion NormRegion_MAX =
    LRNParameter_NormRegion_NormRegion_MAX;
  static const int NormRegion_ARRAYSIZE =
    LRNParameter_NormRegion_NormRegion_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NormRegion_descriptor() {
    return LRNParameter_NormRegion_descriptor();
  }
  static inline const ::std::string& NormRegion_Name(NormRegion value) {
    return LRNParameter_NormRegion_Name(value);
  }
  static inline bool NormRegion_Parse(const ::std::string& name,
      NormRegion* value) {
    return LRNParameter_NormRegion_Parse(name, value);
  }

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

  // optional uint32 local_size = 1 [default = 5];
  inline bool has_local_size() const;
  inline void clear_local_size();
  static const int kLocalSizeFieldNumber = 1;
  inline ::google::protobuf::uint32 local_size() const;
  inline void set_local_size(::google::protobuf::uint32 value);

  // optional float alpha = 2 [default = 1];
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 2;
  inline float alpha() const;
  inline void set_alpha(float value);

  // optional float beta = 3 [default = 0.75];
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 3;
  inline float beta() const;
  inline void set_beta(float value);

  // optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
  inline bool has_norm_region() const;
  inline void clear_norm_region();
  static const int kNormRegionFieldNumber = 4;
  inline ::caffe::LRNParameter_NormRegion norm_region() const;
  inline void set_norm_region(::caffe::LRNParameter_NormRegion value);

  // optional float k = 5 [default = 1];
  inline bool has_k() const;
  inline void clear_k();
  static const int kKFieldNumber = 5;
  inline float k() const;
  inline void set_k(float value);

  // @@protoc_insertion_point(class_scope:caffe.LRNParameter)
 private:
  inline void set_has_local_size();
  inline void clear_has_local_size();
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  inline void set_has_norm_region();
  inline void clear_has_norm_region();
  inline void set_has_k();
  inline void clear_has_k();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 local_size_;
  float alpha_;
  float beta_;
  int norm_region_;
  float k_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static LRNParameter* default_instance_;
};
// -------------------------------------------------------------------

class MemoryDataParameter : public ::google::protobuf::Message {
 public:
  MemoryDataParameter();
  virtual ~MemoryDataParameter();

  MemoryDataParameter(const MemoryDataParameter& from);

  inline MemoryDataParameter& operator=(const MemoryDataParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const MemoryDataParameter& default_instance();

  void Swap(MemoryDataParameter* other);

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

  MemoryDataParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MemoryDataParameter& from);
  void MergeFrom(const MemoryDataParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional uint32 batch_size = 1;
  inline bool has_batch_size() const;
  inline void clear_batch_size();
  static const int kBatchSizeFieldNumber = 1;
  inline ::google::protobuf::uint32 batch_size() const;
  inline void set_batch_size(::google::protobuf::uint32 value);

  // optional uint32 channels = 2;
  inline bool has_channels() const;
  inline void clear_channels();
  static const int kChannelsFieldNumber = 2;
  inline ::google::protobuf::uint32 channels() const;
  inline void set_channels(::google::protobuf::uint32 value);

  // optional uint32 height = 3;
  inline bool has_height() const;
  inline void clear_height();
  static const int kHeightFieldNumber = 3;
  inline ::google::protobuf::uint32 height() const;
  inline void set_height(::google::protobuf::uint32 value);

  // optional uint32 width = 4;
  inline bool has_width() const;
  inline void clear_width();
  static const int kWidthFieldNumber = 4;
  inline ::google::protobuf::uint32 width() const;
  inline void set_width(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:caffe.MemoryDataParameter)
 private:
  inline void set_has_batch_size();
  inline void clear_has_batch_size();
  inline void set_has_channels();
  inline void clear_has_channels();
  inline void set_has_height();
  inline void clear_has_height();
  inline void set_has_width();
  inline void clear_has_width();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 batch_size_;
  ::google::protobuf::uint32 channels_;
  ::google::protobuf::uint32 height_;
  ::google::protobuf::uint32 width_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static MemoryDataParameter* default_instance_;
};
// -------------------------------------------------------------------

class MVNParameter : public ::google::protobuf::Message {
 public:
  MVNParameter();
  virtual ~MVNParameter();

  MVNParameter(const MVNParameter& from);

  inline MVNParameter& operator=(const MVNParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const MVNParameter& default_instance();

  void Swap(MVNParameter* other);

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

  MVNParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MVNParameter& from);
  void MergeFrom(const MVNParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional bool normalize_variance = 1 [default = true];
  inline bool has_normalize_variance() const;
  inline void clear_normalize_variance();
  static const int kNormalizeVarianceFieldNumber = 1;
  inline bool normalize_variance() const;
  inline void set_normalize_variance(bool value);

  // optional bool across_channels = 2 [default = false];
  inline bool has_across_channels() const;
  inline void clear_across_channels();
  static const int kAcrossChannelsFieldNumber = 2;
  inline bool across_channels() const;
  inline void set_across_channels(bool value);

  // @@protoc_insertion_point(class_scope:caffe.MVNParameter)
 private:
  inline void set_has_normalize_variance();
  inline void clear_has_normalize_variance();
  inline void set_has_across_channels();
  inline void clear_has_across_channels();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool normalize_variance_;
  bool across_channels_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static MVNParameter* default_instance_;
};
// -------------------------------------------------------------------

class PoolingParameter : public ::google::protobuf::Message {
 public:
  PoolingParameter();
  virtual ~PoolingParameter();

  PoolingParameter(const PoolingParameter& from);

  inline PoolingParameter& operator=(const PoolingParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PoolingParameter& default_instance();

  void Swap(PoolingParameter* other);

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

  PoolingParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PoolingParameter& from);
  void MergeFrom(const PoolingParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef PoolingParameter_PoolMethod PoolMethod;
  static const PoolMethod MAX = PoolingParameter_PoolMethod_MAX;
  static const PoolMethod AVE = PoolingParameter_PoolMethod_AVE;
  static const PoolMethod STOCHASTIC = PoolingParameter_PoolMethod_STOCHASTIC;
  static inline bool PoolMethod_IsValid(int value) {
    return PoolingParameter_PoolMethod_IsValid(value);
  }
  static const PoolMethod PoolMethod_MIN =
    PoolingParameter_PoolMethod_PoolMethod_MIN;
  static const PoolMethod PoolMethod_MAX =
    PoolingParameter_PoolMethod_PoolMethod_MAX;
  static const int PoolMethod_ARRAYSIZE =
    PoolingParameter_PoolMethod_PoolMethod_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  PoolMethod_descriptor() {
    return PoolingParameter_PoolMethod_descriptor();
  }
  static inline const ::std::string& PoolMethod_Name(PoolMethod value) {
    return PoolingParameter_PoolMethod_Name(value);
  }
  static inline bool PoolMethod_Parse(const ::std::string& name,
      PoolMethod* value) {
    return PoolingParameter_PoolMethod_Parse(name, value);
  }

  typedef PoolingParameter_Engine Engine;
  static const Engine DEFAULT = PoolingParameter_Engine_DEFAULT;
  static const Engine CAFFE = PoolingParameter_Engine_CAFFE;
  static const Engine CUDNN = PoolingParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return PoolingParameter_Engine_IsValid(value);
  }
  static const Engine Engine_MIN =
    PoolingParameter_Engine_Engine_MIN;
  static const Engine Engine_MAX =
    PoolingParameter_Engine_Engine_MAX;
  static const int Engine_ARRAYSIZE =
    PoolingParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Engine_descriptor() {
    return PoolingParameter_Engine_descriptor();
  }
  static inline const ::std::string& Engine_Name(Engine value) {
    return PoolingParameter_Engine_Name(value);
  }
  static inline bool Engine_Parse(const ::std::string& name,
      Engine* value) {
    return PoolingParameter_Engine_Parse(name, value);
  }

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

  // optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
  inline bool has_pool() const;
  inline void clear_pool();
  static const int kPoolFieldNumber = 1;
  inline ::caffe::PoolingParameter_PoolMethod pool() const;
  inline void set_pool(::caffe::PoolingParameter_PoolMethod value);

  // optional uint32 pad = 4 [default = 0];
  inline bool has_pad() const;
  inline void clear_pad();
  static const int kPadFieldNumber = 4;
  inline ::google::protobuf::uint32 pad() const;
  inline void set_pad(::google::protobuf::uint32 value);

  // optional uint32 pad_h = 9 [default = 0];
  inline bool has_pad_h() const;
  inline void clear_pad_h();
  static const int kPadHFieldNumber = 9;
  inline ::google::protobuf::uint32 pad_h() const;
  inline void set_pad_h(::google::protobuf::uint32 value);

  // optional uint32 pad_w = 10 [default = 0];
  inline bool has_pad_w() const;
  inline void clear_pad_w();
  static const int kPadWFieldNumber = 10;
  inline ::google::protobuf::uint32 pad_w() const;
  inline void set_pad_w(::google::protobuf::uint32 value);

  // optional uint32 kernel_size = 2;
  inline bool has_kernel_size() const;
  inline void clear_kernel_size();
  static const int kKernelSizeFieldNumber = 2;
  inline ::google::protobuf::uint32 kernel_size() const;
  inline void set_kernel_size(::google::protobuf::uint32 value);

  // optional uint32 kernel_h = 5;
  inline bool has_kernel_h() const;
  inline void clear_kernel_h();
  static const int kKernelHFieldNumber = 5;
  inline ::google::protobuf::uint32 kernel_h() const;
  inline void set_kernel_h(::google::protobuf::uint32 value);

  // optional uint32 kernel_w = 6;
  inline bool has_kernel_w() const;
  inline void clear_kernel_w();
  static const int kKernelWFieldNumber = 6;
  inline ::google::protobuf::uint32 kernel_w() const;
  inline void set_kernel_w(::google::protobuf::uint32 value);

  // optional uint32 stride = 3 [default = 1];
  inline bool has_stride() const;
  inline void clear_stride();
  static const int kStrideFieldNumber = 3;
  inline ::google::protobuf::uint32 stride() const;
  inline void set_stride(::google::protobuf::uint32 value);

  // optional uint32 stride_h = 7;
  inline bool has_stride_h() const;
  inline void clear_stride_h();
  static const int kStrideHFieldNumber = 7;
  inline ::google::protobuf::uint32 stride_h() const;
  inline void set_stride_h(::google::protobuf::uint32 value);

  // optional uint32 stride_w = 8;
  inline bool has_stride_w() const;
  inline void clear_stride_w();
  static const int kStrideWFieldNumber = 8;
  inline ::google::protobuf::uint32 stride_w() const;
  inline void set_stride_w(::google::protobuf::uint32 value);

  // optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 11;
  inline ::caffe::PoolingParameter_Engine engine() const;
  inline void set_engine(::caffe::PoolingParameter_Engine value);

  // optional bool global_pooling = 12 [default = false];
  inline bool has_global_pooling() const;
  inline void clear_global_pooling();
  static const int kGlobalPoolingFieldNumber = 12;
  inline bool global_pooling() const;
  inline void set_global_pooling(bool value);

  // @@protoc_insertion_point(class_scope:caffe.PoolingParameter)
 private:
  inline void set_has_pool();
  inline void clear_has_pool();
  inline void set_has_pad();
  inline void clear_has_pad();
  inline void set_has_pad_h();
  inline void clear_has_pad_h();
  inline void set_has_pad_w();
  inline void clear_has_pad_w();
  inline void set_has_kernel_size();
  inline void clear_has_kernel_size();
  inline void set_has_kernel_h();
  inline void clear_has_kernel_h();
  inline void set_has_kernel_w();
  inline void clear_has_kernel_w();
  inline void set_has_stride();
  inline void clear_has_stride();
  inline void set_has_stride_h();
  inline void clear_has_stride_h();
  inline void set_has_stride_w();
  inline void clear_has_stride_w();
  inline void set_has_engine();
  inline void clear_has_engine();
  inline void set_has_global_pooling();
  inline void clear_has_global_pooling();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int pool_;
  ::google::protobuf::uint32 pad_;
  ::google::protobuf::uint32 pad_h_;
  ::google::protobuf::uint32 pad_w_;
  ::google::protobuf::uint32 kernel_size_;
  ::google::protobuf::uint32 kernel_h_;
  ::google::protobuf::uint32 kernel_w_;
  ::google::protobuf::uint32 stride_;
  ::google::protobuf::uint32 stride_h_;
  ::google::protobuf::uint32 stride_w_;
  int engine_;
  bool global_pooling_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static PoolingParameter* default_instance_;
};
// -------------------------------------------------------------------

class PowerParameter : public ::google::protobuf::Message {
 public:
  PowerParameter();
  virtual ~PowerParameter();

  PowerParameter(const PowerParameter& from);

  inline PowerParameter& operator=(const PowerParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PowerParameter& default_instance();

  void Swap(PowerParameter* other);

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

  PowerParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PowerParameter& from);
  void MergeFrom(const PowerParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional float power = 1 [default = 1];
  inline bool has_power() const;
  inline void clear_power();
  static const int kPowerFieldNumber = 1;
  inline float power() const;
  inline void set_power(float value);

  // optional float scale = 2 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline float scale() const;
  inline void set_scale(float value);

  // optional float shift = 3 [default = 0];
  inline bool has_shift() const;
  inline void clear_shift();
  static const int kShiftFieldNumber = 3;
  inline float shift() const;
  inline void set_shift(float value);

  // @@protoc_insertion_point(class_scope:caffe.PowerParameter)
 private:
  inline void set_has_power();
  inline void clear_has_power();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_shift();
  inline void clear_has_shift();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float power_;
  float scale_;
  float shift_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static PowerParameter* default_instance_;
};
// -------------------------------------------------------------------

class ReLUParameter : public ::google::protobuf::Message {
 public:
  ReLUParameter();
  virtual ~ReLUParameter();

  ReLUParameter(const ReLUParameter& from);

  inline ReLUParameter& operator=(const ReLUParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ReLUParameter& default_instance();

  void Swap(ReLUParameter* other);

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

  ReLUParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ReLUParameter& from);
  void MergeFrom(const ReLUParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef ReLUParameter_Engine Engine;
  static const Engine DEFAULT = ReLUParameter_Engine_DEFAULT;
  static const Engine CAFFE = ReLUParameter_Engine_CAFFE;
  static const Engine CUDNN = ReLUParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return ReLUParameter_Engine_IsValid(value);
  }
  static const Engine Engine_MIN =
    ReLUParameter_Engine_Engine_MIN;
  static const Engine Engine_MAX =
    ReLUParameter_Engine_Engine_MAX;
  static const int Engine_ARRAYSIZE =
    ReLUParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Engine_descriptor() {
    return ReLUParameter_Engine_descriptor();
  }
  static inline const ::std::string& Engine_Name(Engine value) {
    return ReLUParameter_Engine_Name(value);
  }
  static inline bool Engine_Parse(const ::std::string& name,
      Engine* value) {
    return ReLUParameter_Engine_Parse(name, value);
  }

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

  // optional float negative_slope = 1 [default = 0];
  inline bool has_negative_slope() const;
  inline void clear_negative_slope();
  static const int kNegativeSlopeFieldNumber = 1;
  inline float negative_slope() const;
  inline void set_negative_slope(float value);

  // optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 2;
  inline ::caffe::ReLUParameter_Engine engine() const;
  inline void set_engine(::caffe::ReLUParameter_Engine value);

  // @@protoc_insertion_point(class_scope:caffe.ReLUParameter)
 private:
  inline void set_has_negative_slope();
  inline void clear_has_negative_slope();
  inline void set_has_engine();
  inline void clear_has_engine();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float negative_slope_;
  int engine_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ReLUParameter* default_instance_;
};
// -------------------------------------------------------------------

class SigmoidParameter : public ::google::protobuf::Message {
 public:
  SigmoidParameter();
  virtual ~SigmoidParameter();

  SigmoidParameter(const SigmoidParameter& from);

  inline SigmoidParameter& operator=(const SigmoidParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SigmoidParameter& default_instance();

  void Swap(SigmoidParameter* other);

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

  SigmoidParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SigmoidParameter& from);
  void MergeFrom(const SigmoidParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef SigmoidParameter_Engine Engine;
  static const Engine DEFAULT = SigmoidParameter_Engine_DEFAULT;
  static const Engine CAFFE = SigmoidParameter_Engine_CAFFE;
  static const Engine CUDNN = SigmoidParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return SigmoidParameter_Engine_IsValid(value);
  }
  static const Engine Engine_MIN =
    SigmoidParameter_Engine_Engine_MIN;
  static const Engine Engine_MAX =
    SigmoidParameter_Engine_Engine_MAX;
  static const int Engine_ARRAYSIZE =
    SigmoidParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Engine_descriptor() {
    return SigmoidParameter_Engine_descriptor();
  }
  static inline const ::std::string& Engine_Name(Engine value) {
    return SigmoidParameter_Engine_Name(value);
  }
  static inline bool Engine_Parse(const ::std::string& name,
      Engine* value) {
    return SigmoidParameter_Engine_Parse(name, value);
  }

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

  // optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 1;
  inline ::caffe::SigmoidParameter_Engine engine() const;
  inline void set_engine(::caffe::SigmoidParameter_Engine value);

  // @@protoc_insertion_point(class_scope:caffe.SigmoidParameter)
 private:
  inline void set_has_engine();
  inline void clear_has_engine();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int engine_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static SigmoidParameter* default_instance_;
};
// -------------------------------------------------------------------

class SliceParameter : public ::google::protobuf::Message {
 public:
  SliceParameter();
  virtual ~SliceParameter();

  SliceParameter(const SliceParameter& from);

  inline SliceParameter& operator=(const SliceParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SliceParameter& default_instance();

  void Swap(SliceParameter* other);

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

  SliceParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SliceParameter& from);
  void MergeFrom(const SliceParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional uint32 slice_dim = 1 [default = 1];
  inline bool has_slice_dim() const;
  inline void clear_slice_dim();
  static const int kSliceDimFieldNumber = 1;
  inline ::google::protobuf::uint32 slice_dim() const;
  inline void set_slice_dim(::google::protobuf::uint32 value);

  // repeated uint32 slice_point = 2;
  inline int slice_point_size() const;
  inline void clear_slice_point();
  static const int kSlicePointFieldNumber = 2;
  inline ::google::protobuf::uint32 slice_point(int index) const;
  inline void set_slice_point(int index, ::google::protobuf::uint32 value);
  inline void add_slice_point(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      slice_point() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_slice_point();

  // @@protoc_insertion_point(class_scope:caffe.SliceParameter)
 private:
  inline void set_has_slice_dim();
  inline void clear_has_slice_dim();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > slice_point_;
  ::google::protobuf::uint32 slice_dim_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static SliceParameter* default_instance_;
};
// -------------------------------------------------------------------

class SoftmaxParameter : public ::google::protobuf::Message {
 public:
  SoftmaxParameter();
  virtual ~SoftmaxParameter();

  SoftmaxParameter(const SoftmaxParameter& from);

  inline SoftmaxParameter& operator=(const SoftmaxParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SoftmaxParameter& default_instance();

  void Swap(SoftmaxParameter* other);

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

  SoftmaxParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SoftmaxParameter& from);
  void MergeFrom(const SoftmaxParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef SoftmaxParameter_Engine Engine;
  static const Engine DEFAULT = SoftmaxParameter_Engine_DEFAULT;
  static const Engine CAFFE = SoftmaxParameter_Engine_CAFFE;
  static const Engine CUDNN = SoftmaxParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return SoftmaxParameter_Engine_IsValid(value);
  }
  static const Engine Engine_MIN =
    SoftmaxParameter_Engine_Engine_MIN;
  static const Engine Engine_MAX =
    SoftmaxParameter_Engine_Engine_MAX;
  static const int Engine_ARRAYSIZE =
    SoftmaxParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Engine_descriptor() {
    return SoftmaxParameter_Engine_descriptor();
  }
  static inline const ::std::string& Engine_Name(Engine value) {
    return SoftmaxParameter_Engine_Name(value);
  }
  static inline bool Engine_Parse(const ::std::string& name,
      Engine* value) {
    return SoftmaxParameter_Engine_Parse(name, value);
  }

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

  // optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 1;
  inline ::caffe::SoftmaxParameter_Engine engine() const;
  inline void set_engine(::caffe::SoftmaxParameter_Engine value);

  // @@protoc_insertion_point(class_scope:caffe.SoftmaxParameter)
 private:
  inline void set_has_engine();
  inline void clear_has_engine();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int engine_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static SoftmaxParameter* default_instance_;
};
// -------------------------------------------------------------------

class TanHParameter : public ::google::protobuf::Message {
 public:
  TanHParameter();
  virtual ~TanHParameter();

  TanHParameter(const TanHParameter& from);

  inline TanHParameter& operator=(const TanHParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TanHParameter& default_instance();

  void Swap(TanHParameter* other);

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

  TanHParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TanHParameter& from);
  void MergeFrom(const TanHParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef TanHParameter_Engine Engine;
  static const Engine DEFAULT = TanHParameter_Engine_DEFAULT;
  static const Engine CAFFE = TanHParameter_Engine_CAFFE;
  static const Engine CUDNN = TanHParameter_Engine_CUDNN;
  static inline bool Engine_IsValid(int value) {
    return TanHParameter_Engine_IsValid(value);
  }
  static const Engine Engine_MIN =
    TanHParameter_Engine_Engine_MIN;
  static const Engine Engine_MAX =
    TanHParameter_Engine_Engine_MAX;
  static const int Engine_ARRAYSIZE =
    TanHParameter_Engine_Engine_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Engine_descriptor() {
    return TanHParameter_Engine_descriptor();
  }
  static inline const ::std::string& Engine_Name(Engine value) {
    return TanHParameter_Engine_Name(value);
  }
  static inline bool Engine_Parse(const ::std::string& name,
      Engine* value) {
    return TanHParameter_Engine_Parse(name, value);
  }

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

  // optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 1;
  inline ::caffe::TanHParameter_Engine engine() const;
  inline void set_engine(::caffe::TanHParameter_Engine value);

  // @@protoc_insertion_point(class_scope:caffe.TanHParameter)
 private:
  inline void set_has_engine();
  inline void clear_has_engine();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int engine_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static TanHParameter* default_instance_;
};
// -------------------------------------------------------------------

class ThresholdParameter : public ::google::protobuf::Message {
 public:
  ThresholdParameter();
  virtual ~ThresholdParameter();

  ThresholdParameter(const ThresholdParameter& from);

  inline ThresholdParameter& operator=(const ThresholdParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ThresholdParameter& default_instance();

  void Swap(ThresholdParameter* other);

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

  ThresholdParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ThresholdParameter& from);
  void MergeFrom(const ThresholdParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional float threshold = 1 [default = 0];
  inline bool has_threshold() const;
  inline void clear_threshold();
  static const int kThresholdFieldNumber = 1;
  inline float threshold() const;
  inline void set_threshold(float value);

  // @@protoc_insertion_point(class_scope:caffe.ThresholdParameter)
 private:
  inline void set_has_threshold();
  inline void clear_has_threshold();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  float threshold_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static ThresholdParameter* default_instance_;
};
// -------------------------------------------------------------------

class WindowDataParameter : public ::google::protobuf::Message {
 public:
  WindowDataParameter();
  virtual ~WindowDataParameter();

  WindowDataParameter(const WindowDataParameter& from);

  inline WindowDataParameter& operator=(const WindowDataParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const WindowDataParameter& default_instance();

  void Swap(WindowDataParameter* other);

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

  WindowDataParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const WindowDataParameter& from);
  void MergeFrom(const WindowDataParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string source = 1;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 1;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // optional float scale = 2 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline float scale() const;
  inline void set_scale(float value);

  // optional string mean_file = 3;
  inline bool has_mean_file() const;
  inline void clear_mean_file();
  static const int kMeanFileFieldNumber = 3;
  inline const ::std::string& mean_file() const;
  inline void set_mean_file(const ::std::string& value);
  inline void set_mean_file(const char* value);
  inline void set_mean_file(const char* value, size_t size);
  inline ::std::string* mutable_mean_file();
  inline ::std::string* release_mean_file();
  inline void set_allocated_mean_file(::std::string* mean_file);

  // optional uint32 batch_size = 4;
  inline bool has_batch_size() const;
  inline void clear_batch_size();
  static const int kBatchSizeFieldNumber = 4;
  inline ::google::protobuf::uint32 batch_size() const;
  inline void set_batch_size(::google::protobuf::uint32 value);

  // optional uint32 crop_size = 5 [default = 0];
  inline bool has_crop_size() const;
  inline void clear_crop_size();
  static const int kCropSizeFieldNumber = 5;
  inline ::google::protobuf::uint32 crop_size() const;
  inline void set_crop_size(::google::protobuf::uint32 value);

  // optional bool mirror = 6 [default = false];
  inline bool has_mirror() const;
  inline void clear_mirror();
  static const int kMirrorFieldNumber = 6;
  inline bool mirror() const;
  inline void set_mirror(bool value);

  // optional float fg_threshold = 7 [default = 0.5];
  inline bool has_fg_threshold() const;
  inline void clear_fg_threshold();
  static const int kFgThresholdFieldNumber = 7;
  inline float fg_threshold() const;
  inline void set_fg_threshold(float value);

  // optional float bg_threshold = 8 [default = 0.5];
  inline bool has_bg_threshold() const;
  inline void clear_bg_threshold();
  static const int kBgThresholdFieldNumber = 8;
  inline float bg_threshold() const;
  inline void set_bg_threshold(float value);

  // optional float fg_fraction = 9 [default = 0.25];
  inline bool has_fg_fraction() const;
  inline void clear_fg_fraction();
  static const int kFgFractionFieldNumber = 9;
  inline float fg_fraction() const;
  inline void set_fg_fraction(float value);

  // optional uint32 context_pad = 10 [default = 0];
  inline bool has_context_pad() const;
  inline void clear_context_pad();
  static const int kContextPadFieldNumber = 10;
  inline ::google::protobuf::uint32 context_pad() const;
  inline void set_context_pad(::google::protobuf::uint32 value);

  // optional string crop_mode = 11 [default = "warp"];
  inline bool has_crop_mode() const;
  inline void clear_crop_mode();
  static const int kCropModeFieldNumber = 11;
  inline const ::std::string& crop_mode() const;
  inline void set_crop_mode(const ::std::string& value);
  inline void set_crop_mode(const char* value);
  inline void set_crop_mode(const char* value, size_t size);
  inline ::std::string* mutable_crop_mode();
  inline ::std::string* release_crop_mode();
  inline void set_allocated_crop_mode(::std::string* crop_mode);

  // optional bool cache_images = 12 [default = false];
  inline bool has_cache_images() const;
  inline void clear_cache_images();
  static const int kCacheImagesFieldNumber = 12;
  inline bool cache_images() const;
  inline void set_cache_images(bool value);

  // optional string root_folder = 13 [default = ""];
  inline bool has_root_folder() const;
  inline void clear_root_folder();
  static const int kRootFolderFieldNumber = 13;
  inline const ::std::string& root_folder() const;
  inline void set_root_folder(const ::std::string& value);
  inline void set_root_folder(const char* value);
  inline void set_root_folder(const char* value, size_t size);
  inline ::std::string* mutable_root_folder();
  inline ::std::string* release_root_folder();
  inline void set_allocated_root_folder(::std::string* root_folder);

  // @@protoc_insertion_point(class_scope:caffe.WindowDataParameter)
 private:
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_mean_file();
  inline void clear_has_mean_file();
  inline void set_has_batch_size();
  inline void clear_has_batch_size();
  inline void set_has_crop_size();
  inline void clear_has_crop_size();
  inline void set_has_mirror();
  inline void clear_has_mirror();
  inline void set_has_fg_threshold();
  inline void clear_has_fg_threshold();
  inline void set_has_bg_threshold();
  inline void clear_has_bg_threshold();
  inline void set_has_fg_fraction();
  inline void clear_has_fg_fraction();
  inline void set_has_context_pad();
  inline void clear_has_context_pad();
  inline void set_has_crop_mode();
  inline void clear_has_crop_mode();
  inline void set_has_cache_images();
  inline void clear_has_cache_images();
  inline void set_has_root_folder();
  inline void clear_has_root_folder();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* source_;
  ::std::string* mean_file_;
  float scale_;
  ::google::protobuf::uint32 batch_size_;
  ::google::protobuf::uint32 crop_size_;
  float fg_threshold_;
  float bg_threshold_;
  float fg_fraction_;
  bool mirror_;
  bool cache_images_;
  ::google::protobuf::uint32 context_pad_;
  ::std::string* crop_mode_;
  static ::std::string* _default_crop_mode_;
  ::std::string* root_folder_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(13 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static WindowDataParameter* default_instance_;
};
// -------------------------------------------------------------------

class V0LayerParameter : public ::google::protobuf::Message {
 public:
  V0LayerParameter();
  virtual ~V0LayerParameter();

  V0LayerParameter(const V0LayerParameter& from);

  inline V0LayerParameter& operator=(const V0LayerParameter& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const V0LayerParameter& default_instance();

  void Swap(V0LayerParameter* other);

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

  V0LayerParameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const V0LayerParameter& from);
  void MergeFrom(const V0LayerParameter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

  typedef V0LayerParameter_PoolMethod PoolMethod;
  static const PoolMethod MAX = V0LayerParameter_PoolMethod_MAX;
  static const PoolMethod AVE = V0LayerParameter_PoolMethod_AVE;
  static const PoolMethod STOCHASTIC = V0LayerParameter_PoolMethod_STOCHASTIC;
  static inline bool PoolMethod_IsValid(int value) {
    return V0LayerParameter_PoolMethod_IsValid(value);
  }
  static const PoolMethod PoolMethod_MIN =
    V0LayerParameter_PoolMethod_PoolMethod_MIN;
  static const PoolMethod PoolMethod_MAX =
    V0LayerParameter_PoolMethod_PoolMethod_MAX;
  static const int PoolMethod_ARRAYSIZE =
    V0LayerParameter_PoolMethod_PoolMethod_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  PoolMethod_descriptor() {
    return V0LayerParameter_PoolMethod_descriptor();
  }
  static inline const ::std::string& PoolMethod_Name(PoolMethod value) {
    return V0LayerParameter_PoolMethod_Name(value);
  }
  static inline bool PoolMethod_Parse(const ::std::string& name,
      PoolMethod* value) {
    return V0LayerParameter_PoolMethod_Parse(name, value);
  }

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

  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // optional string type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline const ::std::string& type() const;
  inline void set_type(const ::std::string& value);
  inline void set_type(const char* value);
  inline void set_type(const char* value, size_t size);
  inline ::std::string* mutable_type();
  inline ::std::string* release_type();
  inline void set_allocated_type(::std::string* type);

  // optional uint32 num_output = 3;
  inline bool has_num_output() const;
  inline void clear_num_output();
  static const int kNumOutputFieldNumber = 3;
  inline ::google::protobuf::uint32 num_output() const;
  inline void set_num_output(::google::protobuf::uint32 value);

  // optional bool biasterm = 4 [default = true];
  inline bool has_biasterm() const;
  inline void clear_biasterm();
  static const int kBiastermFieldNumber = 4;
  inline bool biasterm() const;
  inline void set_biasterm(bool value);

  // optional .caffe.FillerParameter weight_filler = 5;
  inline bool has_weight_filler() const;
  inline void clear_weight_filler();
  static const int kWeightFillerFieldNumber = 5;
  inline const ::caffe::FillerParameter& weight_filler() const;
  inline ::caffe::FillerParameter* mutable_weight_filler();
  inline ::caffe::FillerParameter* release_weight_filler();
  inline void set_allocated_weight_filler(::caffe::FillerParameter* weight_filler);

  // optional .caffe.FillerParameter bias_filler = 6;
  inline bool has_bias_filler() const;
  inline void clear_bias_filler();
  static const int kBiasFillerFieldNumber = 6;
  inline const ::caffe::FillerParameter& bias_filler() const;
  inline ::caffe::FillerParameter* mutable_bias_filler();
  inline ::caffe::FillerParameter* release_bias_filler();
  inline void set_allocated_bias_filler(::caffe::FillerParameter* bias_filler);

  // optional uint32 pad = 7 [default = 0];
  inline bool has_pad() const;
  inline void clear_pad();
  static const int kPadFieldNumber = 7;
  inline ::google::protobuf::uint32 pad() const;
  inline void set_pad(::google::protobuf::uint32 value);

  // optional uint32 kernelsize = 8;
  inline bool has_kernelsize() const;
  inline void clear_kernelsize();
  static const int kKernelsizeFieldNumber = 8;
  inline ::google::protobuf::uint32 kernelsize() const;
  inline void set_kernelsize(::google::protobuf::uint32 value);

  // optional uint32 group = 9 [default = 1];
  inline bool has_group() const;
  inline void clear_group();
  static const int kGroupFieldNumber = 9;
  inline ::google::protobuf::uint32 group() const;
  inline void set_group(::google::protobuf::uint32 value);

  // optional uint32 stride = 10 [default = 1];
  inline bool has_stride() const;
  inline void clear_stride();
  static const int kStrideFieldNumber = 10;
  inline ::google::protobuf::uint32 stride() const;
  inline void set_stride(::google::protobuf::uint32 value);

  // optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
  inline bool has_pool() const;
  inline void clear_pool();
  static const int kPoolFieldNumber = 11;
  inline ::caffe::V0LayerParameter_PoolMethod pool() const;
  inline void set_pool(::caffe::V0LayerParameter_PoolMethod value);

  // optional float dropout_ratio = 12 [default = 0.5];
  inline bool has_dropout_ratio() const;
  inline void clear_dropout_ratio();
  static const int kDropoutRatioFieldNumber = 12;
  inline float dropout_ratio() const;
  inline void set_dropout_ratio(float value);

  // optional uint32 local_size = 13 [default = 5];
  inline bool has_local_size() const;
  inline void clear_local_size();
  static const int kLocalSizeFieldNumber = 13;
  inline ::google::protobuf::uint32 local_size() const;
  inline void set_local_size(::google::protobuf::uint32 value);

  // optional float alpha = 14 [default = 1];
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 14;
  inline float alpha() const;
  inline void set_alpha(float value);

  // optional float beta = 15 [default = 0.75];
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 15;
  inline float beta() const;
  inline void set_beta(float value);

  // optional float k = 22 [default = 1];
  inline bool has_k() const;
  inline void clear_k();
  static const int kKFieldNumber = 22;
  inline float k() const;
  inline void set_k(float value);

  // optional string source = 16;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 16;
  inline const ::std::string& source() const;
  inline void set_source(const ::std::string& value);
  inline void set_source(const char* value);
  inline void set_source(const char* value, size_t size);
  inline ::std::string* mutable_source();
  inline ::std::string* release_source();
  inline void set_allocated_source(::std::string* source);

  // optional float scale = 17 [default = 1];
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 17;
  inline float scale() const;
  inline void set_scale(float value);

  // optional string meanfile = 18;
  inline bool has_meanfile() const;
  inline void clear_meanfile();
  static const int kMeanfileFieldNumber = 18;
  inline const ::std::string& meanfile() const;
  inline void set_meanfile(const ::std::string& value);
  inline void set_meanfile(const char* value);
  inline void set_meanfile(const char* value, size_t size);
  inline ::std::string* mutable_meanfile();
  inline ::std::string* release_meanfile();
  inline void set_allocated_meanfile(::std::string* meanfile);

  // optional uint32 batchsize = 19;
  inline bool has_batchsize() const;
  inline void clear_batchsize();
  static const int kBatchsizeFieldNumber = 19;
  inline ::google::protobuf::uint32 batchsize() const;
  inline void set_batchsize(::google::protobuf::uint32 value);

  // optional uint32 cropsize = 20 [default = 0];
  inline bool has_cropsize() const;
  inline void clear_cropsize();
  static const int kCropsizeFieldNumber = 20;
  inline ::google::protobuf::uint32 cropsize() const;
  inline void set_cropsize(::google::protobuf::uint32 value);

  // optional bool mirror = 21 [default = false];
  inline bool has_mirror() const;
  inline void clear_mirror();
  static const int kMirrorFieldNumber = 21;
  inline bool mirror() const;
  inline void set_mirror(bool value);

  // repeated .caffe.BlobProto blobs = 50;
  inline int blobs_size() const;
  inline void clear_blobs();
  static const int kBlobsFieldNumber = 50;
  inline const ::caffe::BlobProto& blobs(int index) const;
  inline ::caffe::BlobProto* mutable_blobs(int index);
  inline ::caffe::BlobProto* add_blobs();
  inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
      blobs() const;
  inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
      mutable_blobs();

  // repeated float blobs_lr = 51;
  inline int blobs_lr_size() const;
  inline void clear_blobs_lr();
  static const int kBlobsLrFieldNumber = 51;
  inline float blobs_lr(int index) const;
  inline void set_blobs_lr(int index, float value);
  inline void add_blobs_lr(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      blobs_lr() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_blobs_lr();

  // repeated float weight_decay = 52;
  inline int weight_decay_size() const;
  inline void clear_weight_decay();
  static const int kWeightDecayFieldNumber = 52;
  inline float weight_decay(int index) const;
  inline void set_weight_decay(int index, float value);
  inline void add_weight_decay(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      weight_decay() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_weight_decay();

  // optional uint32 rand_skip = 53 [default = 0];
  inline bool has_rand_skip() const;
  inline void clear_rand_skip();
  static const int kRandSkipFieldNumber = 53;
  inline ::google::protobuf::uint32 rand_skip() const;
  inline void set_rand_skip(::google::protobuf::uint32 value);

  // optional float det_fg_threshold = 54 [default = 0.5];
  inline bool has_det_fg_threshold() const;
  inline void clear_det_fg_threshold();
  static const int kDetFgThresholdFieldNumber = 54;
  inline float det_fg_threshold() const;
  inline void set_det_fg_threshold(float value);

  // optional float det_bg_threshold = 55 [default = 0.5];
  inline bool has_det_bg_threshold() const;
  inline void clear_det_bg_threshold();
  static const int kDetBgThresholdFieldNumber = 55;
  inline float det_bg_threshold() const;
  inline void set_det_bg_threshold(float value);

  // optional float det_fg_fraction = 56 [default = 0.25];
  inline bool has_det_fg_fraction() const;
  inline void clear_det_fg_fraction();
  static const int kDetFgFractionFieldNumber = 56;
  inline float det_fg_fraction() const;
  inline void set_det_fg_fraction(float value);

  // optional uint32 det_context_pad = 58 [default = 0];
  inline bool has_det_context_pad() const;
  inline void clear_det_context_pad();
  static const int kDetContextPadFieldNumber = 58;
  inline ::google::protobuf::uint32 det_context_pad() const;
  inline void set_det_context_pad(::google::protobuf::uint32 value);

  // optional string det_crop_mode = 59 [default = "warp"];
  inline bool has_det_crop_mode() const;
  inline void clear_det_crop_mode();
  static const int kDetCropModeFieldNumber = 59;
  inline const ::std::string& det_crop_mode() const;
  inline void set_det_crop_mode(const ::std::string& value);
  inline void set_det_crop_mode(const char* value);
  inline void set_det_crop_mode(const char* value, size_t size);
  inline ::std::string* mutable_det_crop_mode();
  inline ::std::string* release_det_crop_mode();
  inline void set_allocated_det_crop_mode(::std::string* det_crop_mode);

  // optional int32 new_num = 60 [default = 0];
  inline bool has_new_num() const;
  inline void clear_new_num();
  static const int kNewNumFieldNumber = 60;
  inline ::google::protobuf::int32 new_num() const;
  inline void set_new_num(::google::protobuf::int32 value);

  // optional int32 new_channels = 61 [default = 0];
  inline bool has_new_channels() const;
  inline void clear_new_channels();
  static const int kNewChannelsFieldNumber = 61;
  inline ::google::protobuf::int32 new_channels() const;
  inline void set_new_channels(::google::protobuf::int32 value);

  // optional int32 new_height = 62 [default = 0];
  inline bool has_new_height() const;
  inline void clear_new_height();
  static const int kNewHeightFieldNumber = 62;
  inline ::google::protobuf::int32 new_height() const;
  inline void set_new_height(::google::protobuf::int32 value);

  // optional int32 new_width = 63 [default = 0];
  inline bool has_new_width() const;
  inline void clear_new_width();
  static const int kNewWidthFieldNumber = 63;
  inline ::google::protobuf::int32 new_width() const;
  inline void set_new_width(::google::protobuf::int32 value);

  // optional bool shuffle_images = 64 [default = false];
  inline bool has_shuffle_images() const;
  inline void clear_shuffle_images();
  static const int kShuffleImagesFieldNumber = 64;
  inline bool shuffle_images() const;
  inline void set_shuffle_images(bool value);

  // optional uint32 concat_dim = 65 [default = 1];
  inline bool has_concat_dim() const;
  inline void clear_concat_dim();
  static const int kConcatDimFieldNumber = 65;
  inline ::google::protobuf::uint32 concat_dim() const;
  inline void set_concat_dim(::google::protobuf::uint32 value);

  // optional .caffe.HDF5OutputParameter hdf5_output_param = 1001;
  inline bool has_hdf5_output_param() const;
  inline void clear_hdf5_output_param();
  static const int kHdf5OutputParamFieldNumber = 1001;
  inline const ::caffe::HDF5OutputParameter& hdf5_output_param() const;
  inline ::caffe::HDF5OutputParameter* mutable_hdf5_output_param();
  inline ::caffe::HDF5OutputParameter* release_hdf5_output_param();
  inline void set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param);

  // @@protoc_insertion_point(class_scope:caffe.V0LayerParameter)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_num_output();
  inline void clear_has_num_output();
  inline void set_has_biasterm();
  inline void clear_has_biasterm();
  inline void set_has_weight_filler();
  inline void clear_has_weight_filler();
  inline void set_has_bias_filler();
  inline void clear_has_bias_filler();
  inline void set_has_pad();
  inline void clear_has_pad();
  inline void set_has_kernelsize();
  inline void clear_has_kernelsize();
  inline void set_has_group();
  inline void clear_has_group();
  inline void set_has_stride();
  inline void clear_has_stride();
  inline void set_has_pool();
  inline void clear_has_pool();
  inline void set_has_dropout_ratio();
  inline void clear_has_dropout_ratio();
  inline void set_has_local_size();
  inline void clear_has_local_size();
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  inline void set_has_k();
  inline void clear_has_k();
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_meanfile();
  inline void clear_has_meanfile();
  inline void set_has_batchsize();
  inline void clear_has_batchsize();
  inline void set_has_cropsize();
  inline void clear_has_cropsize();
  inline void set_has_mirror();
  inline void clear_has_mirror();
  inline void set_has_rand_skip();
  inline void clear_has_rand_skip();
  inline void set_has_det_fg_threshold();
  inline void clear_has_det_fg_threshold();
  inline void set_has_det_bg_threshold();
  inline void clear_has_det_bg_threshold();
  inline void set_has_det_fg_fraction();
  inline void clear_has_det_fg_fraction();
  inline void set_has_det_context_pad();
  inline void clear_has_det_context_pad();
  inline void set_has_det_crop_mode();
  inline void clear_has_det_crop_mode();
  inline void set_has_new_num();
  inline void clear_has_new_num();
  inline void set_has_new_channels();
  inline void clear_has_new_channels();
  inline void set_has_new_height();
  inline void clear_has_new_height();
  inline void set_has_new_width();
  inline void clear_has_new_width();
  inline void set_has_shuffle_images();
  inline void clear_has_shuffle_images();
  inline void set_has_concat_dim();
  inline void clear_has_concat_dim();
  inline void set_has_hdf5_output_param();
  inline void clear_has_hdf5_output_param();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* type_;
  ::caffe::FillerParameter* weight_filler_;
  ::google::protobuf::uint32 num_output_;
  ::google::protobuf::uint32 pad_;
  ::caffe::FillerParameter* bias_filler_;
  ::google::protobuf::uint32 kernelsize_;
  ::google::protobuf::uint32 group_;
  ::google::protobuf::uint32 stride_;
  int pool_;
  float dropout_ratio_;
  ::google::protobuf::uint32 local_size_;
  float alpha_;
  float beta_;
  float k_;
  float scale_;
  ::std::string* source_;
  ::std::string* meanfile_;
  ::google::protobuf::uint32 batchsize_;
  bool biasterm_;
  bool mirror_;
  bool shuffle_images_;
  ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto > blobs_;
  ::google::protobuf::uint32 cropsize_;
  ::google::protobuf::uint32 rand_skip_;
  ::google::protobuf::RepeatedField< float > blobs_lr_;
  ::google::protobuf::RepeatedField< float > weight_decay_;
  float det_fg_threshold_;
  float det_bg_threshold_;
  float det_fg_fraction_;
  ::google::protobuf::uint32 det_context_pad_;
  ::std::string* det_crop_mode_;
  static ::std::string* _default_det_crop_mode_;
  ::google::protobuf::int32 new_num_;
  ::google::protobuf::int32 new_channels_;
  ::google::protobuf::int32 new_height_;
  ::google::protobuf::int32 new_width_;
  ::caffe::HDF5OutputParameter* hdf5_output_param_;
  ::google::protobuf::uint32 concat_dim_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(38 + 31) / 32];

  friend void  protobuf_AddDesc_caffe_2eproto();
  friend void protobuf_AssignDesc_caffe_2eproto();
  friend void protobuf_ShutdownFile_caffe_2eproto();

  void InitAsDefaultInstance();
  static V0LayerParameter* default_instance_;
};
// ===================================================================


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

// BlobProto

// optional int32 num = 1 [default = 0];
inline bool BlobProto::has_num() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlobProto::set_has_num() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlobProto::clear_has_num() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlobProto::clear_num() {
  num_ = 0;
  clear_has_num();
}
inline ::google::protobuf::int32 BlobProto::num() const {
  return num_;
}
inline void BlobProto::set_num(::google::protobuf::int32 value) {
  set_has_num();
  num_ = value;
}

// optional int32 channels = 2 [default = 0];
inline bool BlobProto::has_channels() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlobProto::set_has_channels() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BlobProto::clear_has_channels() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BlobProto::clear_channels() {
  channels_ = 0;
  clear_has_channels();
}
inline ::google::protobuf::int32 BlobProto::channels() const {
  return channels_;
}
inline void BlobProto::set_channels(::google::protobuf::int32 value) {
  set_has_channels();
  channels_ = value;
}

// optional int32 height = 3 [default = 0];
inline bool BlobProto::has_height() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlobProto::set_has_height() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BlobProto::clear_has_height() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BlobProto::clear_height() {
  height_ = 0;
  clear_has_height();
}
inline ::google::protobuf::int32 BlobProto::height() const {
  return height_;
}
inline void BlobProto::set_height(::google::protobuf::int32 value) {
  set_has_height();
  height_ = value;
}

// optional int32 width = 4 [default = 0];
inline bool BlobProto::has_width() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BlobProto::set_has_width() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BlobProto::clear_has_width() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BlobProto::clear_width() {
  width_ = 0;
  clear_has_width();
}
inline ::google::protobuf::int32 BlobProto::width() const {
  return width_;
}
inline void BlobProto::set_width(::google::protobuf::int32 value) {
  set_has_width();
  width_ = value;
}

// repeated float data = 5 [packed = true];
inline int BlobProto::data_size() const {
  return data_.size();
}
inline void BlobProto::clear_data() {
  data_.Clear();
}
inline float BlobProto::data(int index) const {
  return data_.Get(index);
}
inline void BlobProto::set_data(int index, float value) {
  data_.Set(index, value);
}
inline void BlobProto::add_data(float value) {
  data_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BlobProto::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedField< float >*
BlobProto::mutable_data() {
  return &data_;
}

// repeated float diff = 6 [packed = true];
inline int BlobProto::diff_size() const {
  return diff_.size();
}
inline void BlobProto::clear_diff() {
  diff_.Clear();
}
inline float BlobProto::diff(int index) const {
  return diff_.Get(index);
}
inline void BlobProto::set_diff(int index, float value) {
  diff_.Set(index, value);
}
inline void BlobProto::add_diff(float value) {
  diff_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BlobProto::diff() const {
  return diff_;
}
inline ::google::protobuf::RepeatedField< float >*
BlobProto::mutable_diff() {
  return &diff_;
}

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

// BlobProtoVector

// repeated .caffe.BlobProto blobs = 1;
inline int BlobProtoVector::blobs_size() const {
  return blobs_.size();
}
inline void BlobProtoVector::clear_blobs() {
  blobs_.Clear();
}
inline const ::caffe::BlobProto& BlobProtoVector::blobs(int index) const {
  return blobs_.Get(index);
}
inline ::caffe::BlobProto* BlobProtoVector::mutable_blobs(int index) {
  return blobs_.Mutable(index);
}
inline ::caffe::BlobProto* BlobProtoVector::add_blobs() {
  return blobs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
BlobProtoVector::blobs() const {
  return blobs_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
BlobProtoVector::mutable_blobs() {
  return &blobs_;
}

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

// Datum

// optional int32 channels = 1;
inline bool Datum::has_channels() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Datum::set_has_channels() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Datum::clear_has_channels() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Datum::clear_channels() {
  channels_ = 0;
  clear_has_channels();
}
inline ::google::protobuf::int32 Datum::channels() const {
  return channels_;
}
inline void Datum::set_channels(::google::protobuf::int32 value) {
  set_has_channels();
  channels_ = value;
}

// optional int32 height = 2;
inline bool Datum::has_height() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Datum::set_has_height() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Datum::clear_has_height() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Datum::clear_height() {
  height_ = 0;
  clear_has_height();
}
inline ::google::protobuf::int32 Datum::height() const {
  return height_;
}
inline void Datum::set_height(::google::protobuf::int32 value) {
  set_has_height();
  height_ = value;
}

// optional int32 width = 3;
inline bool Datum::has_width() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Datum::set_has_width() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Datum::clear_has_width() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Datum::clear_width() {
  width_ = 0;
  clear_has_width();
}
inline ::google::protobuf::int32 Datum::width() const {
  return width_;
}
inline void Datum::set_width(::google::protobuf::int32 value) {
  set_has_width();
  width_ = value;
}

// optional bytes data = 4;
inline bool Datum::has_data() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Datum::set_has_data() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Datum::clear_has_data() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Datum::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& Datum::data() const {
  return *data_;
}
inline void Datum::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Datum::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Datum::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Datum::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* Datum::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Datum::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 label = 5;
inline bool Datum::has_label() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Datum::set_has_label() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Datum::clear_has_label() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Datum::clear_label() {
  label_ = 0;
  clear_has_label();
}
inline ::google::protobuf::int32 Datum::label() const {
  return label_;
}
inline void Datum::set_label(::google::protobuf::int32 value) {
  set_has_label();
  label_ = value;
}

// repeated float float_data = 6;
inline int Datum::float_data_size() const {
  return float_data_.size();
}
inline void Datum::clear_float_data() {
  float_data_.Clear();
}
inline float Datum::float_data(int index) const {
  return float_data_.Get(index);
}
inline void Datum::set_float_data(int index, float value) {
  float_data_.Set(index, value);
}
inline void Datum::add_float_data(float value) {
  float_data_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
Datum::float_data() const {
  return float_data_;
}
inline ::google::protobuf::RepeatedField< float >*
Datum::mutable_float_data() {
  return &float_data_;
}

// optional bool encoded = 7 [default = false];
inline bool Datum::has_encoded() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Datum::set_has_encoded() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Datum::clear_has_encoded() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Datum::clear_encoded() {
  encoded_ = false;
  clear_has_encoded();
}
inline bool Datum::encoded() const {
  return encoded_;
}
inline void Datum::set_encoded(bool value) {
  set_has_encoded();
  encoded_ = value;
}

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

// FillerParameter

// optional string type = 1 [default = "constant"];
inline bool FillerParameter::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FillerParameter::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FillerParameter::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FillerParameter::clear_type() {
  if (type_ != _default_type_) {
    type_->assign(*_default_type_);
  }
  clear_has_type();
}
inline const ::std::string& FillerParameter::type() const {
  return *type_;
}
inline void FillerParameter::set_type(const ::std::string& value) {
  set_has_type();
  if (type_ == _default_type_) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void FillerParameter::set_type(const char* value) {
  set_has_type();
  if (type_ == _default_type_) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void FillerParameter::set_type(const char* value, size_t size) {
  set_has_type();
  if (type_ == _default_type_) {
    type_ = new ::std::string;
  }
  type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* FillerParameter::mutable_type() {
  set_has_type();
  if (type_ == _default_type_) {
    type_ = new ::std::string(*_default_type_);
  }
  return type_;
}
inline ::std::string* FillerParameter::release_type() {
  clear_has_type();
  if (type_ == _default_type_) {
    return NULL;
  } else {
    ::std::string* temp = type_;
    type_ = const_cast< ::std::string*>(_default_type_);
    return temp;
  }
}
inline void FillerParameter::set_allocated_type(::std::string* type) {
  if (type_ != _default_type_) {
    delete type_;
  }
  if (type) {
    set_has_type();
    type_ = type;
  } else {
    clear_has_type();
    type_ = const_cast< ::std::string*>(_default_type_);
  }
}

// optional float value = 2 [default = 0];
inline bool FillerParameter::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FillerParameter::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FillerParameter::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FillerParameter::clear_value() {
  value_ = 0;
  clear_has_value();
}
inline float FillerParameter::value() const {
  return value_;
}
inline void FillerParameter::set_value(float value) {
  set_has_value();
  value_ = value;
}

// optional float min = 3 [default = 0];
inline bool FillerParameter::has_min() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void FillerParameter::set_has_min() {
  _has_bits_[0] |= 0x00000004u;
}
inline void FillerParameter::clear_has_min() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void FillerParameter::clear_min() {
  min_ = 0;
  clear_has_min();
}
inline float FillerParameter::min() const {
  return min_;
}
inline void FillerParameter::set_min(float value) {
  set_has_min();
  min_ = value;
}

// optional float max = 4 [default = 1];
inline bool FillerParameter::has_max() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FillerParameter::set_has_max() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FillerParameter::clear_has_max() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FillerParameter::clear_max() {
  max_ = 1;
  clear_has_max();
}
inline float FillerParameter::max() const {
  return max_;
}
inline void FillerParameter::set_max(float value) {
  set_has_max();
  max_ = value;
}

// optional float mean = 5 [default = 0];
inline bool FillerParameter::has_mean() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FillerParameter::set_has_mean() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FillerParameter::clear_has_mean() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FillerParameter::clear_mean() {
  mean_ = 0;
  clear_has_mean();
}
inline float FillerParameter::mean() const {
  return mean_;
}
inline void FillerParameter::set_mean(float value) {
  set_has_mean();
  mean_ = value;
}

// optional float std = 6 [default = 1];
inline bool FillerParameter::has_std() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void FillerParameter::set_has_std() {
  _has_bits_[0] |= 0x00000020u;
}
inline void FillerParameter::clear_has_std() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void FillerParameter::clear_std() {
  std_ = 1;
  clear_has_std();
}
inline float FillerParameter::std() const {
  return std_;
}
inline void FillerParameter::set_std(float value) {
  set_has_std();
  std_ = value;
}

// optional int32 sparse = 7 [default = -1];
inline bool FillerParameter::has_sparse() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void FillerParameter::set_has_sparse() {
  _has_bits_[0] |= 0x00000040u;
}
inline void FillerParameter::clear_has_sparse() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void FillerParameter::clear_sparse() {
  sparse_ = -1;
  clear_has_sparse();
}
inline ::google::protobuf::int32 FillerParameter::sparse() const {
  return sparse_;
}
inline void FillerParameter::set_sparse(::google::protobuf::int32 value) {
  set_has_sparse();
  sparse_ = value;
}

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

// NetParameter

// optional string name = 1;
inline bool NetParameter::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NetParameter::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NetParameter::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NetParameter::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& NetParameter::name() const {
  return *name_;
}
inline void NetParameter::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void NetParameter::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void NetParameter::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* NetParameter::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* NetParameter::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void NetParameter::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated .caffe.LayerParameter layers = 2;
inline int NetParameter::layers_size() const {
  return layers_.size();
}
inline void NetParameter::clear_layers() {
  layers_.Clear();
}
inline const ::caffe::LayerParameter& NetParameter::layers(int index) const {
  return layers_.Get(index);
}
inline ::caffe::LayerParameter* NetParameter::mutable_layers(int index) {
  return layers_.Mutable(index);
}
inline ::caffe::LayerParameter* NetParameter::add_layers() {
  return layers_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >&
NetParameter::layers() const {
  return layers_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::LayerParameter >*
NetParameter::mutable_layers() {
  return &layers_;
}

// repeated string input = 3;
inline int NetParameter::input_size() const {
  return input_.size();
}
inline void NetParameter::clear_input() {
  input_.Clear();
}
inline const ::std::string& NetParameter::input(int index) const {
  return input_.Get(index);
}
inline ::std::string* NetParameter::mutable_input(int index) {
  return input_.Mutable(index);
}
inline void NetParameter::set_input(int index, const ::std::string& value) {
  input_.Mutable(index)->assign(value);
}
inline void NetParameter::set_input(int index, const char* value) {
  input_.Mutable(index)->assign(value);
}
inline void NetParameter::set_input(int index, const char* value, size_t size) {
  input_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* NetParameter::add_input() {
  return input_.Add();
}
inline void NetParameter::add_input(const ::std::string& value) {
  input_.Add()->assign(value);
}
inline void NetParameter::add_input(const char* value) {
  input_.Add()->assign(value);
}
inline void NetParameter::add_input(const char* value, size_t size) {
  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetParameter::input() const {
  return input_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetParameter::mutable_input() {
  return &input_;
}

// repeated int32 input_dim = 4;
inline int NetParameter::input_dim_size() const {
  return input_dim_.size();
}
inline void NetParameter::clear_input_dim() {
  input_dim_.Clear();
}
inline ::google::protobuf::int32 NetParameter::input_dim(int index) const {
  return input_dim_.Get(index);
}
inline void NetParameter::set_input_dim(int index, ::google::protobuf::int32 value) {
  input_dim_.Set(index, value);
}
inline void NetParameter::add_input_dim(::google::protobuf::int32 value) {
  input_dim_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
NetParameter::input_dim() const {
  return input_dim_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
NetParameter::mutable_input_dim() {
  return &input_dim_;
}

// optional bool force_backward = 5 [default = false];
inline bool NetParameter::has_force_backward() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NetParameter::set_has_force_backward() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NetParameter::clear_has_force_backward() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NetParameter::clear_force_backward() {
  force_backward_ = false;
  clear_has_force_backward();
}
inline bool NetParameter::force_backward() const {
  return force_backward_;
}
inline void NetParameter::set_force_backward(bool value) {
  set_has_force_backward();
  force_backward_ = value;
}

// optional .caffe.NetState state = 6;
inline bool NetParameter::has_state() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void NetParameter::set_has_state() {
  _has_bits_[0] |= 0x00000020u;
}
inline void NetParameter::clear_has_state() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void NetParameter::clear_state() {
  if (state_ != NULL) state_->::caffe::NetState::Clear();
  clear_has_state();
}
inline const ::caffe::NetState& NetParameter::state() const {
  return state_ != NULL ? *state_ : *default_instance_->state_;
}
inline ::caffe::NetState* NetParameter::mutable_state() {
  set_has_state();
  if (state_ == NULL) state_ = new ::caffe::NetState;
  return state_;
}
inline ::caffe::NetState* NetParameter::release_state() {
  clear_has_state();
  ::caffe::NetState* temp = state_;
  state_ = NULL;
  return temp;
}
inline void NetParameter::set_allocated_state(::caffe::NetState* state) {
  delete state_;
  state_ = state;
  if (state) {
    set_has_state();
  } else {
    clear_has_state();
  }
}

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

// SolverParameter

// optional string net = 24;
inline bool SolverParameter::has_net() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SolverParameter::set_has_net() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SolverParameter::clear_has_net() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SolverParameter::clear_net() {
  if (net_ != &::google::protobuf::internal::kEmptyString) {
    net_->clear();
  }
  clear_has_net();
}
inline const ::std::string& SolverParameter::net() const {
  return *net_;
}
inline void SolverParameter::set_net(const ::std::string& value) {
  set_has_net();
  if (net_ == &::google::protobuf::internal::kEmptyString) {
    net_ = new ::std::string;
  }
  net_->assign(value);
}
inline void SolverParameter::set_net(const char* value) {
  set_has_net();
  if (net_ == &::google::protobuf::internal::kEmptyString) {
    net_ = new ::std::string;
  }
  net_->assign(value);
}
inline void SolverParameter::set_net(const char* value, size_t size) {
  set_has_net();
  if (net_ == &::google::protobuf::internal::kEmptyString) {
    net_ = new ::std::string;
  }
  net_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverParameter::mutable_net() {
  set_has_net();
  if (net_ == &::google::protobuf::internal::kEmptyString) {
    net_ = new ::std::string;
  }
  return net_;
}
inline ::std::string* SolverParameter::release_net() {
  clear_has_net();
  if (net_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = net_;
    net_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SolverParameter::set_allocated_net(::std::string* net) {
  if (net_ != &::google::protobuf::internal::kEmptyString) {
    delete net_;
  }
  if (net) {
    set_has_net();
    net_ = net;
  } else {
    clear_has_net();
    net_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .caffe.NetParameter net_param = 25;
inline bool SolverParameter::has_net_param() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SolverParameter::set_has_net_param() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SolverParameter::clear_has_net_param() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SolverParameter::clear_net_param() {
  if (net_param_ != NULL) net_param_->::caffe::NetParameter::Clear();
  clear_has_net_param();
}
inline const ::caffe::NetParameter& SolverParameter::net_param() const {
  return net_param_ != NULL ? *net_param_ : *default_instance_->net_param_;
}
inline ::caffe::NetParameter* SolverParameter::mutable_net_param() {
  set_has_net_param();
  if (net_param_ == NULL) net_param_ = new ::caffe::NetParameter;
  return net_param_;
}
inline ::caffe::NetParameter* SolverParameter::release_net_param() {
  clear_has_net_param();
  ::caffe::NetParameter* temp = net_param_;
  net_param_ = NULL;
  return temp;
}
inline void SolverParameter::set_allocated_net_param(::caffe::NetParameter* net_param) {
  delete net_param_;
  net_param_ = net_param;
  if (net_param) {
    set_has_net_param();
  } else {
    clear_has_net_param();
  }
}

// optional string train_net = 1;
inline bool SolverParameter::has_train_net() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SolverParameter::set_has_train_net() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SolverParameter::clear_has_train_net() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SolverParameter::clear_train_net() {
  if (train_net_ != &::google::protobuf::internal::kEmptyString) {
    train_net_->clear();
  }
  clear_has_train_net();
}
inline const ::std::string& SolverParameter::train_net() const {
  return *train_net_;
}
inline void SolverParameter::set_train_net(const ::std::string& value) {
  set_has_train_net();
  if (train_net_ == &::google::protobuf::internal::kEmptyString) {
    train_net_ = new ::std::string;
  }
  train_net_->assign(value);
}
inline void SolverParameter::set_train_net(const char* value) {
  set_has_train_net();
  if (train_net_ == &::google::protobuf::internal::kEmptyString) {
    train_net_ = new ::std::string;
  }
  train_net_->assign(value);
}
inline void SolverParameter::set_train_net(const char* value, size_t size) {
  set_has_train_net();
  if (train_net_ == &::google::protobuf::internal::kEmptyString) {
    train_net_ = new ::std::string;
  }
  train_net_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverParameter::mutable_train_net() {
  set_has_train_net();
  if (train_net_ == &::google::protobuf::internal::kEmptyString) {
    train_net_ = new ::std::string;
  }
  return train_net_;
}
inline ::std::string* SolverParameter::release_train_net() {
  clear_has_train_net();
  if (train_net_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = train_net_;
    train_net_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SolverParameter::set_allocated_train_net(::std::string* train_net) {
  if (train_net_ != &::google::protobuf::internal::kEmptyString) {
    delete train_net_;
  }
  if (train_net) {
    set_has_train_net();
    train_net_ = train_net;
  } else {
    clear_has_train_net();
    train_net_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated string test_net = 2;
inline int SolverParameter::test_net_size() const {
  return test_net_.size();
}
inline void SolverParameter::clear_test_net() {
  test_net_.Clear();
}
inline const ::std::string& SolverParameter::test_net(int index) const {
  return test_net_.Get(index);
}
inline ::std::string* SolverParameter::mutable_test_net(int index) {
  return test_net_.Mutable(index);
}
inline void SolverParameter::set_test_net(int index, const ::std::string& value) {
  test_net_.Mutable(index)->assign(value);
}
inline void SolverParameter::set_test_net(int index, const char* value) {
  test_net_.Mutable(index)->assign(value);
}
inline void SolverParameter::set_test_net(int index, const char* value, size_t size) {
  test_net_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverParameter::add_test_net() {
  return test_net_.Add();
}
inline void SolverParameter::add_test_net(const ::std::string& value) {
  test_net_.Add()->assign(value);
}
inline void SolverParameter::add_test_net(const char* value) {
  test_net_.Add()->assign(value);
}
inline void SolverParameter::add_test_net(const char* value, size_t size) {
  test_net_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
SolverParameter::test_net() const {
  return test_net_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
SolverParameter::mutable_test_net() {
  return &test_net_;
}

// optional .caffe.NetParameter train_net_param = 21;
inline bool SolverParameter::has_train_net_param() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SolverParameter::set_has_train_net_param() {
  _has_bits_[0] |= 0x00000010u;
}
inline void SolverParameter::clear_has_train_net_param() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void SolverParameter::clear_train_net_param() {
  if (train_net_param_ != NULL) train_net_param_->::caffe::NetParameter::Clear();
  clear_has_train_net_param();
}
inline const ::caffe::NetParameter& SolverParameter::train_net_param() const {
  return train_net_param_ != NULL ? *train_net_param_ : *default_instance_->train_net_param_;
}
inline ::caffe::NetParameter* SolverParameter::mutable_train_net_param() {
  set_has_train_net_param();
  if (train_net_param_ == NULL) train_net_param_ = new ::caffe::NetParameter;
  return train_net_param_;
}
inline ::caffe::NetParameter* SolverParameter::release_train_net_param() {
  clear_has_train_net_param();
  ::caffe::NetParameter* temp = train_net_param_;
  train_net_param_ = NULL;
  return temp;
}
inline void SolverParameter::set_allocated_train_net_param(::caffe::NetParameter* train_net_param) {
  delete train_net_param_;
  train_net_param_ = train_net_param;
  if (train_net_param) {
    set_has_train_net_param();
  } else {
    clear_has_train_net_param();
  }
}

// repeated .caffe.NetParameter test_net_param = 22;
inline int SolverParameter::test_net_param_size() const {
  return test_net_param_.size();
}
inline void SolverParameter::clear_test_net_param() {
  test_net_param_.Clear();
}
inline const ::caffe::NetParameter& SolverParameter::test_net_param(int index) const {
  return test_net_param_.Get(index);
}
inline ::caffe::NetParameter* SolverParameter::mutable_test_net_param(int index) {
  return test_net_param_.Mutable(index);
}
inline ::caffe::NetParameter* SolverParameter::add_test_net_param() {
  return test_net_param_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >&
SolverParameter::test_net_param() const {
  return test_net_param_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::NetParameter >*
SolverParameter::mutable_test_net_param() {
  return &test_net_param_;
}

// optional .caffe.NetState train_state = 26;
inline bool SolverParameter::has_train_state() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void SolverParameter::set_has_train_state() {
  _has_bits_[0] |= 0x00000040u;
}
inline void SolverParameter::clear_has_train_state() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void SolverParameter::clear_train_state() {
  if (train_state_ != NULL) train_state_->::caffe::NetState::Clear();
  clear_has_train_state();
}
inline const ::caffe::NetState& SolverParameter::train_state() const {
  return train_state_ != NULL ? *train_state_ : *default_instance_->train_state_;
}
inline ::caffe::NetState* SolverParameter::mutable_train_state() {
  set_has_train_state();
  if (train_state_ == NULL) train_state_ = new ::caffe::NetState;
  return train_state_;
}
inline ::caffe::NetState* SolverParameter::release_train_state() {
  clear_has_train_state();
  ::caffe::NetState* temp = train_state_;
  train_state_ = NULL;
  return temp;
}
inline void SolverParameter::set_allocated_train_state(::caffe::NetState* train_state) {
  delete train_state_;
  train_state_ = train_state;
  if (train_state) {
    set_has_train_state();
  } else {
    clear_has_train_state();
  }
}

// repeated .caffe.NetState test_state = 27;
inline int SolverParameter::test_state_size() const {
  return test_state_.size();
}
inline void SolverParameter::clear_test_state() {
  test_state_.Clear();
}
inline const ::caffe::NetState& SolverParameter::test_state(int index) const {
  return test_state_.Get(index);
}
inline ::caffe::NetState* SolverParameter::mutable_test_state(int index) {
  return test_state_.Mutable(index);
}
inline ::caffe::NetState* SolverParameter::add_test_state() {
  return test_state_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetState >&
SolverParameter::test_state() const {
  return test_state_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::NetState >*
SolverParameter::mutable_test_state() {
  return &test_state_;
}

// repeated int32 test_iter = 3;
inline int SolverParameter::test_iter_size() const {
  return test_iter_.size();
}
inline void SolverParameter::clear_test_iter() {
  test_iter_.Clear();
}
inline ::google::protobuf::int32 SolverParameter::test_iter(int index) const {
  return test_iter_.Get(index);
}
inline void SolverParameter::set_test_iter(int index, ::google::protobuf::int32 value) {
  test_iter_.Set(index, value);
}
inline void SolverParameter::add_test_iter(::google::protobuf::int32 value) {
  test_iter_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SolverParameter::test_iter() const {
  return test_iter_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SolverParameter::mutable_test_iter() {
  return &test_iter_;
}

// optional int32 test_interval = 4 [default = 0];
inline bool SolverParameter::has_test_interval() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void SolverParameter::set_has_test_interval() {
  _has_bits_[0] |= 0x00000200u;
}
inline void SolverParameter::clear_has_test_interval() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void SolverParameter::clear_test_interval() {
  test_interval_ = 0;
  clear_has_test_interval();
}
inline ::google::protobuf::int32 SolverParameter::test_interval() const {
  return test_interval_;
}
inline void SolverParameter::set_test_interval(::google::protobuf::int32 value) {
  set_has_test_interval();
  test_interval_ = value;
}

// optional bool test_compute_loss = 19 [default = false];
inline bool SolverParameter::has_test_compute_loss() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void SolverParameter::set_has_test_compute_loss() {
  _has_bits_[0] |= 0x00000400u;
}
inline void SolverParameter::clear_has_test_compute_loss() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void SolverParameter::clear_test_compute_loss() {
  test_compute_loss_ = false;
  clear_has_test_compute_loss();
}
inline bool SolverParameter::test_compute_loss() const {
  return test_compute_loss_;
}
inline void SolverParameter::set_test_compute_loss(bool value) {
  set_has_test_compute_loss();
  test_compute_loss_ = value;
}

// optional bool test_initialization = 32 [default = true];
inline bool SolverParameter::has_test_initialization() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void SolverParameter::set_has_test_initialization() {
  _has_bits_[0] |= 0x00000800u;
}
inline void SolverParameter::clear_has_test_initialization() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void SolverParameter::clear_test_initialization() {
  test_initialization_ = true;
  clear_has_test_initialization();
}
inline bool SolverParameter::test_initialization() const {
  return test_initialization_;
}
inline void SolverParameter::set_test_initialization(bool value) {
  set_has_test_initialization();
  test_initialization_ = value;
}

// optional float base_lr = 5;
inline bool SolverParameter::has_base_lr() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void SolverParameter::set_has_base_lr() {
  _has_bits_[0] |= 0x00001000u;
}
inline void SolverParameter::clear_has_base_lr() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void SolverParameter::clear_base_lr() {
  base_lr_ = 0;
  clear_has_base_lr();
}
inline float SolverParameter::base_lr() const {
  return base_lr_;
}
inline void SolverParameter::set_base_lr(float value) {
  set_has_base_lr();
  base_lr_ = value;
}

// optional int32 display = 6;
inline bool SolverParameter::has_display() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void SolverParameter::set_has_display() {
  _has_bits_[0] |= 0x00002000u;
}
inline void SolverParameter::clear_has_display() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void SolverParameter::clear_display() {
  display_ = 0;
  clear_has_display();
}
inline ::google::protobuf::int32 SolverParameter::display() const {
  return display_;
}
inline void SolverParameter::set_display(::google::protobuf::int32 value) {
  set_has_display();
  display_ = value;
}

// optional int32 average_loss = 33 [default = 1];
inline bool SolverParameter::has_average_loss() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void SolverParameter::set_has_average_loss() {
  _has_bits_[0] |= 0x00004000u;
}
inline void SolverParameter::clear_has_average_loss() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void SolverParameter::clear_average_loss() {
  average_loss_ = 1;
  clear_has_average_loss();
}
inline ::google::protobuf::int32 SolverParameter::average_loss() const {
  return average_loss_;
}
inline void SolverParameter::set_average_loss(::google::protobuf::int32 value) {
  set_has_average_loss();
  average_loss_ = value;
}

// optional int32 max_iter = 7;
inline bool SolverParameter::has_max_iter() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void SolverParameter::set_has_max_iter() {
  _has_bits_[0] |= 0x00008000u;
}
inline void SolverParameter::clear_has_max_iter() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void SolverParameter::clear_max_iter() {
  max_iter_ = 0;
  clear_has_max_iter();
}
inline ::google::protobuf::int32 SolverParameter::max_iter() const {
  return max_iter_;
}
inline void SolverParameter::set_max_iter(::google::protobuf::int32 value) {
  set_has_max_iter();
  max_iter_ = value;
}

// optional int32 iter_size = 35 [default = 1];
inline bool SolverParameter::has_iter_size() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void SolverParameter::set_has_iter_size() {
  _has_bits_[0] |= 0x00010000u;
}
inline void SolverParameter::clear_has_iter_size() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void SolverParameter::clear_iter_size() {
  iter_size_ = 1;
  clear_has_iter_size();
}
inline ::google::protobuf::int32 SolverParameter::iter_size() const {
  return iter_size_;
}
inline void SolverParameter::set_iter_size(::google::protobuf::int32 value) {
  set_has_iter_size();
  iter_size_ = value;
}

// optional string lr_policy = 8;
inline bool SolverParameter::has_lr_policy() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void SolverParameter::set_has_lr_policy() {
  _has_bits_[0] |= 0x00020000u;
}
inline void SolverParameter::clear_has_lr_policy() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void SolverParameter::clear_lr_policy() {
  if (lr_policy_ != &::google::protobuf::internal::kEmptyString) {
    lr_policy_->clear();
  }
  clear_has_lr_policy();
}
inline const ::std::string& SolverParameter::lr_policy() const {
  return *lr_policy_;
}
inline void SolverParameter::set_lr_policy(const ::std::string& value) {
  set_has_lr_policy();
  if (lr_policy_ == &::google::protobuf::internal::kEmptyString) {
    lr_policy_ = new ::std::string;
  }
  lr_policy_->assign(value);
}
inline void SolverParameter::set_lr_policy(const char* value) {
  set_has_lr_policy();
  if (lr_policy_ == &::google::protobuf::internal::kEmptyString) {
    lr_policy_ = new ::std::string;
  }
  lr_policy_->assign(value);
}
inline void SolverParameter::set_lr_policy(const char* value, size_t size) {
  set_has_lr_policy();
  if (lr_policy_ == &::google::protobuf::internal::kEmptyString) {
    lr_policy_ = new ::std::string;
  }
  lr_policy_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverParameter::mutable_lr_policy() {
  set_has_lr_policy();
  if (lr_policy_ == &::google::protobuf::internal::kEmptyString) {
    lr_policy_ = new ::std::string;
  }
  return lr_policy_;
}
inline ::std::string* SolverParameter::release_lr_policy() {
  clear_has_lr_policy();
  if (lr_policy_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lr_policy_;
    lr_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SolverParameter::set_allocated_lr_policy(::std::string* lr_policy) {
  if (lr_policy_ != &::google::protobuf::internal::kEmptyString) {
    delete lr_policy_;
  }
  if (lr_policy) {
    set_has_lr_policy();
    lr_policy_ = lr_policy;
  } else {
    clear_has_lr_policy();
    lr_policy_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional float gamma = 9;
inline bool SolverParameter::has_gamma() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void SolverParameter::set_has_gamma() {
  _has_bits_[0] |= 0x00040000u;
}
inline void SolverParameter::clear_has_gamma() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void SolverParameter::clear_gamma() {
  gamma_ = 0;
  clear_has_gamma();
}
inline float SolverParameter::gamma() const {
  return gamma_;
}
inline void SolverParameter::set_gamma(float value) {
  set_has_gamma();
  gamma_ = value;
}

// optional float power = 10;
inline bool SolverParameter::has_power() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void SolverParameter::set_has_power() {
  _has_bits_[0] |= 0x00080000u;
}
inline void SolverParameter::clear_has_power() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void SolverParameter::clear_power() {
  power_ = 0;
  clear_has_power();
}
inline float SolverParameter::power() const {
  return power_;
}
inline void SolverParameter::set_power(float value) {
  set_has_power();
  power_ = value;
}

// optional float momentum = 11;
inline bool SolverParameter::has_momentum() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void SolverParameter::set_has_momentum() {
  _has_bits_[0] |= 0x00100000u;
}
inline void SolverParameter::clear_has_momentum() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void SolverParameter::clear_momentum() {
  momentum_ = 0;
  clear_has_momentum();
}
inline float SolverParameter::momentum() const {
  return momentum_;
}
inline void SolverParameter::set_momentum(float value) {
  set_has_momentum();
  momentum_ = value;
}

// optional float weight_decay = 12;
inline bool SolverParameter::has_weight_decay() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void SolverParameter::set_has_weight_decay() {
  _has_bits_[0] |= 0x00200000u;
}
inline void SolverParameter::clear_has_weight_decay() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void SolverParameter::clear_weight_decay() {
  weight_decay_ = 0;
  clear_has_weight_decay();
}
inline float SolverParameter::weight_decay() const {
  return weight_decay_;
}
inline void SolverParameter::set_weight_decay(float value) {
  set_has_weight_decay();
  weight_decay_ = value;
}

// optional string regularization_type = 29 [default = "L2"];
inline bool SolverParameter::has_regularization_type() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void SolverParameter::set_has_regularization_type() {
  _has_bits_[0] |= 0x00400000u;
}
inline void SolverParameter::clear_has_regularization_type() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void SolverParameter::clear_regularization_type() {
  if (regularization_type_ != _default_regularization_type_) {
    regularization_type_->assign(*_default_regularization_type_);
  }
  clear_has_regularization_type();
}
inline const ::std::string& SolverParameter::regularization_type() const {
  return *regularization_type_;
}
inline void SolverParameter::set_regularization_type(const ::std::string& value) {
  set_has_regularization_type();
  if (regularization_type_ == _default_regularization_type_) {
    regularization_type_ = new ::std::string;
  }
  regularization_type_->assign(value);
}
inline void SolverParameter::set_regularization_type(const char* value) {
  set_has_regularization_type();
  if (regularization_type_ == _default_regularization_type_) {
    regularization_type_ = new ::std::string;
  }
  regularization_type_->assign(value);
}
inline void SolverParameter::set_regularization_type(const char* value, size_t size) {
  set_has_regularization_type();
  if (regularization_type_ == _default_regularization_type_) {
    regularization_type_ = new ::std::string;
  }
  regularization_type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverParameter::mutable_regularization_type() {
  set_has_regularization_type();
  if (regularization_type_ == _default_regularization_type_) {
    regularization_type_ = new ::std::string(*_default_regularization_type_);
  }
  return regularization_type_;
}
inline ::std::string* SolverParameter::release_regularization_type() {
  clear_has_regularization_type();
  if (regularization_type_ == _default_regularization_type_) {
    return NULL;
  } else {
    ::std::string* temp = regularization_type_;
    regularization_type_ = const_cast< ::std::string*>(_default_regularization_type_);
    return temp;
  }
}
inline void SolverParameter::set_allocated_regularization_type(::std::string* regularization_type) {
  if (regularization_type_ != _default_regularization_type_) {
    delete regularization_type_;
  }
  if (regularization_type) {
    set_has_regularization_type();
    regularization_type_ = regularization_type;
  } else {
    clear_has_regularization_type();
    regularization_type_ = const_cast< ::std::string*>(_default_regularization_type_);
  }
}

// optional int32 stepsize = 13;
inline bool SolverParameter::has_stepsize() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void SolverParameter::set_has_stepsize() {
  _has_bits_[0] |= 0x00800000u;
}
inline void SolverParameter::clear_has_stepsize() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void SolverParameter::clear_stepsize() {
  stepsize_ = 0;
  clear_has_stepsize();
}
inline ::google::protobuf::int32 SolverParameter::stepsize() const {
  return stepsize_;
}
inline void SolverParameter::set_stepsize(::google::protobuf::int32 value) {
  set_has_stepsize();
  stepsize_ = value;
}

// repeated int32 stepvalue = 34;
inline int SolverParameter::stepvalue_size() const {
  return stepvalue_.size();
}
inline void SolverParameter::clear_stepvalue() {
  stepvalue_.Clear();
}
inline ::google::protobuf::int32 SolverParameter::stepvalue(int index) const {
  return stepvalue_.Get(index);
}
inline void SolverParameter::set_stepvalue(int index, ::google::protobuf::int32 value) {
  stepvalue_.Set(index, value);
}
inline void SolverParameter::add_stepvalue(::google::protobuf::int32 value) {
  stepvalue_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SolverParameter::stepvalue() const {
  return stepvalue_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SolverParameter::mutable_stepvalue() {
  return &stepvalue_;
}

// optional int32 snapshot = 14 [default = 0];
inline bool SolverParameter::has_snapshot() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void SolverParameter::set_has_snapshot() {
  _has_bits_[0] |= 0x02000000u;
}
inline void SolverParameter::clear_has_snapshot() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void SolverParameter::clear_snapshot() {
  snapshot_ = 0;
  clear_has_snapshot();
}
inline ::google::protobuf::int32 SolverParameter::snapshot() const {
  return snapshot_;
}
inline void SolverParameter::set_snapshot(::google::protobuf::int32 value) {
  set_has_snapshot();
  snapshot_ = value;
}

// optional string snapshot_prefix = 15;
inline bool SolverParameter::has_snapshot_prefix() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void SolverParameter::set_has_snapshot_prefix() {
  _has_bits_[0] |= 0x04000000u;
}
inline void SolverParameter::clear_has_snapshot_prefix() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void SolverParameter::clear_snapshot_prefix() {
  if (snapshot_prefix_ != &::google::protobuf::internal::kEmptyString) {
    snapshot_prefix_->clear();
  }
  clear_has_snapshot_prefix();
}
inline const ::std::string& SolverParameter::snapshot_prefix() const {
  return *snapshot_prefix_;
}
inline void SolverParameter::set_snapshot_prefix(const ::std::string& value) {
  set_has_snapshot_prefix();
  if (snapshot_prefix_ == &::google::protobuf::internal::kEmptyString) {
    snapshot_prefix_ = new ::std::string;
  }
  snapshot_prefix_->assign(value);
}
inline void SolverParameter::set_snapshot_prefix(const char* value) {
  set_has_snapshot_prefix();
  if (snapshot_prefix_ == &::google::protobuf::internal::kEmptyString) {
    snapshot_prefix_ = new ::std::string;
  }
  snapshot_prefix_->assign(value);
}
inline void SolverParameter::set_snapshot_prefix(const char* value, size_t size) {
  set_has_snapshot_prefix();
  if (snapshot_prefix_ == &::google::protobuf::internal::kEmptyString) {
    snapshot_prefix_ = new ::std::string;
  }
  snapshot_prefix_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverParameter::mutable_snapshot_prefix() {
  set_has_snapshot_prefix();
  if (snapshot_prefix_ == &::google::protobuf::internal::kEmptyString) {
    snapshot_prefix_ = new ::std::string;
  }
  return snapshot_prefix_;
}
inline ::std::string* SolverParameter::release_snapshot_prefix() {
  clear_has_snapshot_prefix();
  if (snapshot_prefix_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = snapshot_prefix_;
    snapshot_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SolverParameter::set_allocated_snapshot_prefix(::std::string* snapshot_prefix) {
  if (snapshot_prefix_ != &::google::protobuf::internal::kEmptyString) {
    delete snapshot_prefix_;
  }
  if (snapshot_prefix) {
    set_has_snapshot_prefix();
    snapshot_prefix_ = snapshot_prefix;
  } else {
    clear_has_snapshot_prefix();
    snapshot_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool snapshot_diff = 16 [default = false];
inline bool SolverParameter::has_snapshot_diff() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void SolverParameter::set_has_snapshot_diff() {
  _has_bits_[0] |= 0x08000000u;
}
inline void SolverParameter::clear_has_snapshot_diff() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void SolverParameter::clear_snapshot_diff() {
  snapshot_diff_ = false;
  clear_has_snapshot_diff();
}
inline bool SolverParameter::snapshot_diff() const {
  return snapshot_diff_;
}
inline void SolverParameter::set_snapshot_diff(bool value) {
  set_has_snapshot_diff();
  snapshot_diff_ = value;
}

// optional .caffe.SolverParameter.SolverMode solver_mode = 17 [default = GPU];
inline bool SolverParameter::has_solver_mode() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void SolverParameter::set_has_solver_mode() {
  _has_bits_[0] |= 0x10000000u;
}
inline void SolverParameter::clear_has_solver_mode() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void SolverParameter::clear_solver_mode() {
  solver_mode_ = 1;
  clear_has_solver_mode();
}
inline ::caffe::SolverParameter_SolverMode SolverParameter::solver_mode() const {
  return static_cast< ::caffe::SolverParameter_SolverMode >(solver_mode_);
}
inline void SolverParameter::set_solver_mode(::caffe::SolverParameter_SolverMode value) {
  assert(::caffe::SolverParameter_SolverMode_IsValid(value));
  set_has_solver_mode();
  solver_mode_ = value;
}

// optional int32 device_id = 18 [default = 0];
inline bool SolverParameter::has_device_id() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void SolverParameter::set_has_device_id() {
  _has_bits_[0] |= 0x20000000u;
}
inline void SolverParameter::clear_has_device_id() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void SolverParameter::clear_device_id() {
  device_id_ = 0;
  clear_has_device_id();
}
inline ::google::protobuf::int32 SolverParameter::device_id() const {
  return device_id_;
}
inline void SolverParameter::set_device_id(::google::protobuf::int32 value) {
  set_has_device_id();
  device_id_ = value;
}

// optional int64 random_seed = 20 [default = -1];
inline bool SolverParameter::has_random_seed() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void SolverParameter::set_has_random_seed() {
  _has_bits_[0] |= 0x40000000u;
}
inline void SolverParameter::clear_has_random_seed() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void SolverParameter::clear_random_seed() {
  random_seed_ = GOOGLE_LONGLONG(-1);
  clear_has_random_seed();
}
inline ::google::protobuf::int64 SolverParameter::random_seed() const {
  return random_seed_;
}
inline void SolverParameter::set_random_seed(::google::protobuf::int64 value) {
  set_has_random_seed();
  random_seed_ = value;
}

// optional .caffe.SolverParameter.SolverType solver_type = 30 [default = SGD];
inline bool SolverParameter::has_solver_type() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void SolverParameter::set_has_solver_type() {
  _has_bits_[0] |= 0x80000000u;
}
inline void SolverParameter::clear_has_solver_type() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void SolverParameter::clear_solver_type() {
  solver_type_ = 0;
  clear_has_solver_type();
}
inline ::caffe::SolverParameter_SolverType SolverParameter::solver_type() const {
  return static_cast< ::caffe::SolverParameter_SolverType >(solver_type_);
}
inline void SolverParameter::set_solver_type(::caffe::SolverParameter_SolverType value) {
  assert(::caffe::SolverParameter_SolverType_IsValid(value));
  set_has_solver_type();
  solver_type_ = value;
}

// optional float delta = 31 [default = 1e-08];
inline bool SolverParameter::has_delta() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void SolverParameter::set_has_delta() {
  _has_bits_[1] |= 0x00000001u;
}
inline void SolverParameter::clear_has_delta() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void SolverParameter::clear_delta() {
  delta_ = 1e-08f;
  clear_has_delta();
}
inline float SolverParameter::delta() const {
  return delta_;
}
inline void SolverParameter::set_delta(float value) {
  set_has_delta();
  delta_ = value;
}

// optional bool debug_info = 23 [default = false];
inline bool SolverParameter::has_debug_info() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void SolverParameter::set_has_debug_info() {
  _has_bits_[1] |= 0x00000002u;
}
inline void SolverParameter::clear_has_debug_info() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void SolverParameter::clear_debug_info() {
  debug_info_ = false;
  clear_has_debug_info();
}
inline bool SolverParameter::debug_info() const {
  return debug_info_;
}
inline void SolverParameter::set_debug_info(bool value) {
  set_has_debug_info();
  debug_info_ = value;
}

// optional bool snapshot_after_train = 28 [default = true];
inline bool SolverParameter::has_snapshot_after_train() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void SolverParameter::set_has_snapshot_after_train() {
  _has_bits_[1] |= 0x00000004u;
}
inline void SolverParameter::clear_has_snapshot_after_train() {
  _has_bits_[1] &= ~0x00000004u;
}
inline void SolverParameter::clear_snapshot_after_train() {
  snapshot_after_train_ = true;
  clear_has_snapshot_after_train();
}
inline bool SolverParameter::snapshot_after_train() const {
  return snapshot_after_train_;
}
inline void SolverParameter::set_snapshot_after_train(bool value) {
  set_has_snapshot_after_train();
  snapshot_after_train_ = value;
}

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

// SolverState

// optional int32 iter = 1;
inline bool SolverState::has_iter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SolverState::set_has_iter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SolverState::clear_has_iter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SolverState::clear_iter() {
  iter_ = 0;
  clear_has_iter();
}
inline ::google::protobuf::int32 SolverState::iter() const {
  return iter_;
}
inline void SolverState::set_iter(::google::protobuf::int32 value) {
  set_has_iter();
  iter_ = value;
}

// optional string learned_net = 2;
inline bool SolverState::has_learned_net() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SolverState::set_has_learned_net() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SolverState::clear_has_learned_net() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SolverState::clear_learned_net() {
  if (learned_net_ != &::google::protobuf::internal::kEmptyString) {
    learned_net_->clear();
  }
  clear_has_learned_net();
}
inline const ::std::string& SolverState::learned_net() const {
  return *learned_net_;
}
inline void SolverState::set_learned_net(const ::std::string& value) {
  set_has_learned_net();
  if (learned_net_ == &::google::protobuf::internal::kEmptyString) {
    learned_net_ = new ::std::string;
  }
  learned_net_->assign(value);
}
inline void SolverState::set_learned_net(const char* value) {
  set_has_learned_net();
  if (learned_net_ == &::google::protobuf::internal::kEmptyString) {
    learned_net_ = new ::std::string;
  }
  learned_net_->assign(value);
}
inline void SolverState::set_learned_net(const char* value, size_t size) {
  set_has_learned_net();
  if (learned_net_ == &::google::protobuf::internal::kEmptyString) {
    learned_net_ = new ::std::string;
  }
  learned_net_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SolverState::mutable_learned_net() {
  set_has_learned_net();
  if (learned_net_ == &::google::protobuf::internal::kEmptyString) {
    learned_net_ = new ::std::string;
  }
  return learned_net_;
}
inline ::std::string* SolverState::release_learned_net() {
  clear_has_learned_net();
  if (learned_net_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = learned_net_;
    learned_net_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SolverState::set_allocated_learned_net(::std::string* learned_net) {
  if (learned_net_ != &::google::protobuf::internal::kEmptyString) {
    delete learned_net_;
  }
  if (learned_net) {
    set_has_learned_net();
    learned_net_ = learned_net;
  } else {
    clear_has_learned_net();
    learned_net_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated .caffe.BlobProto history = 3;
inline int SolverState::history_size() const {
  return history_.size();
}
inline void SolverState::clear_history() {
  history_.Clear();
}
inline const ::caffe::BlobProto& SolverState::history(int index) const {
  return history_.Get(index);
}
inline ::caffe::BlobProto* SolverState::mutable_history(int index) {
  return history_.Mutable(index);
}
inline ::caffe::BlobProto* SolverState::add_history() {
  return history_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
SolverState::history() const {
  return history_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
SolverState::mutable_history() {
  return &history_;
}

// optional int32 current_step = 4 [default = 0];
inline bool SolverState::has_current_step() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SolverState::set_has_current_step() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SolverState::clear_has_current_step() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SolverState::clear_current_step() {
  current_step_ = 0;
  clear_has_current_step();
}
inline ::google::protobuf::int32 SolverState::current_step() const {
  return current_step_;
}
inline void SolverState::set_current_step(::google::protobuf::int32 value) {
  set_has_current_step();
  current_step_ = value;
}

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

// NetState

// optional .caffe.Phase phase = 1 [default = TEST];
inline bool NetState::has_phase() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NetState::set_has_phase() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NetState::clear_has_phase() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NetState::clear_phase() {
  phase_ = 1;
  clear_has_phase();
}
inline ::caffe::Phase NetState::phase() const {
  return static_cast< ::caffe::Phase >(phase_);
}
inline void NetState::set_phase(::caffe::Phase value) {
  assert(::caffe::Phase_IsValid(value));
  set_has_phase();
  phase_ = value;
}

// optional int32 level = 2 [default = 0];
inline bool NetState::has_level() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NetState::set_has_level() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NetState::clear_has_level() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NetState::clear_level() {
  level_ = 0;
  clear_has_level();
}
inline ::google::protobuf::int32 NetState::level() const {
  return level_;
}
inline void NetState::set_level(::google::protobuf::int32 value) {
  set_has_level();
  level_ = value;
}

// repeated string stage = 3;
inline int NetState::stage_size() const {
  return stage_.size();
}
inline void NetState::clear_stage() {
  stage_.Clear();
}
inline const ::std::string& NetState::stage(int index) const {
  return stage_.Get(index);
}
inline ::std::string* NetState::mutable_stage(int index) {
  return stage_.Mutable(index);
}
inline void NetState::set_stage(int index, const ::std::string& value) {
  stage_.Mutable(index)->assign(value);
}
inline void NetState::set_stage(int index, const char* value) {
  stage_.Mutable(index)->assign(value);
}
inline void NetState::set_stage(int index, const char* value, size_t size) {
  stage_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* NetState::add_stage() {
  return stage_.Add();
}
inline void NetState::add_stage(const ::std::string& value) {
  stage_.Add()->assign(value);
}
inline void NetState::add_stage(const char* value) {
  stage_.Add()->assign(value);
}
inline void NetState::add_stage(const char* value, size_t size) {
  stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetState::stage() const {
  return stage_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetState::mutable_stage() {
  return &stage_;
}

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

// NetStateRule

// optional .caffe.Phase phase = 1;
inline bool NetStateRule::has_phase() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NetStateRule::set_has_phase() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NetStateRule::clear_has_phase() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NetStateRule::clear_phase() {
  phase_ = 0;
  clear_has_phase();
}
inline ::caffe::Phase NetStateRule::phase() const {
  return static_cast< ::caffe::Phase >(phase_);
}
inline void NetStateRule::set_phase(::caffe::Phase value) {
  assert(::caffe::Phase_IsValid(value));
  set_has_phase();
  phase_ = value;
}

// optional int32 min_level = 2;
inline bool NetStateRule::has_min_level() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NetStateRule::set_has_min_level() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NetStateRule::clear_has_min_level() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NetStateRule::clear_min_level() {
  min_level_ = 0;
  clear_has_min_level();
}
inline ::google::protobuf::int32 NetStateRule::min_level() const {
  return min_level_;
}
inline void NetStateRule::set_min_level(::google::protobuf::int32 value) {
  set_has_min_level();
  min_level_ = value;
}

// optional int32 max_level = 3;
inline bool NetStateRule::has_max_level() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NetStateRule::set_has_max_level() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NetStateRule::clear_has_max_level() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NetStateRule::clear_max_level() {
  max_level_ = 0;
  clear_has_max_level();
}
inline ::google::protobuf::int32 NetStateRule::max_level() const {
  return max_level_;
}
inline void NetStateRule::set_max_level(::google::protobuf::int32 value) {
  set_has_max_level();
  max_level_ = value;
}

// repeated string stage = 4;
inline int NetStateRule::stage_size() const {
  return stage_.size();
}
inline void NetStateRule::clear_stage() {
  stage_.Clear();
}
inline const ::std::string& NetStateRule::stage(int index) const {
  return stage_.Get(index);
}
inline ::std::string* NetStateRule::mutable_stage(int index) {
  return stage_.Mutable(index);
}
inline void NetStateRule::set_stage(int index, const ::std::string& value) {
  stage_.Mutable(index)->assign(value);
}
inline void NetStateRule::set_stage(int index, const char* value) {
  stage_.Mutable(index)->assign(value);
}
inline void NetStateRule::set_stage(int index, const char* value, size_t size) {
  stage_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* NetStateRule::add_stage() {
  return stage_.Add();
}
inline void NetStateRule::add_stage(const ::std::string& value) {
  stage_.Add()->assign(value);
}
inline void NetStateRule::add_stage(const char* value) {
  stage_.Add()->assign(value);
}
inline void NetStateRule::add_stage(const char* value, size_t size) {
  stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetStateRule::stage() const {
  return stage_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetStateRule::mutable_stage() {
  return &stage_;
}

// repeated string not_stage = 5;
inline int NetStateRule::not_stage_size() const {
  return not_stage_.size();
}
inline void NetStateRule::clear_not_stage() {
  not_stage_.Clear();
}
inline const ::std::string& NetStateRule::not_stage(int index) const {
  return not_stage_.Get(index);
}
inline ::std::string* NetStateRule::mutable_not_stage(int index) {
  return not_stage_.Mutable(index);
}
inline void NetStateRule::set_not_stage(int index, const ::std::string& value) {
  not_stage_.Mutable(index)->assign(value);
}
inline void NetStateRule::set_not_stage(int index, const char* value) {
  not_stage_.Mutable(index)->assign(value);
}
inline void NetStateRule::set_not_stage(int index, const char* value, size_t size) {
  not_stage_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* NetStateRule::add_not_stage() {
  return not_stage_.Add();
}
inline void NetStateRule::add_not_stage(const ::std::string& value) {
  not_stage_.Add()->assign(value);
}
inline void NetStateRule::add_not_stage(const char* value) {
  not_stage_.Add()->assign(value);
}
inline void NetStateRule::add_not_stage(const char* value, size_t size) {
  not_stage_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
NetStateRule::not_stage() const {
  return not_stage_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
NetStateRule::mutable_not_stage() {
  return &not_stage_;
}

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

// LayerParameter

// repeated string bottom = 2;
inline int LayerParameter::bottom_size() const {
  return bottom_.size();
}
inline void LayerParameter::clear_bottom() {
  bottom_.Clear();
}
inline const ::std::string& LayerParameter::bottom(int index) const {
  return bottom_.Get(index);
}
inline ::std::string* LayerParameter::mutable_bottom(int index) {
  return bottom_.Mutable(index);
}
inline void LayerParameter::set_bottom(int index, const ::std::string& value) {
  bottom_.Mutable(index)->assign(value);
}
inline void LayerParameter::set_bottom(int index, const char* value) {
  bottom_.Mutable(index)->assign(value);
}
inline void LayerParameter::set_bottom(int index, const char* value, size_t size) {
  bottom_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerParameter::add_bottom() {
  return bottom_.Add();
}
inline void LayerParameter::add_bottom(const ::std::string& value) {
  bottom_.Add()->assign(value);
}
inline void LayerParameter::add_bottom(const char* value) {
  bottom_.Add()->assign(value);
}
inline void LayerParameter::add_bottom(const char* value, size_t size) {
  bottom_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerParameter::bottom() const {
  return bottom_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerParameter::mutable_bottom() {
  return &bottom_;
}

// repeated string top = 3;
inline int LayerParameter::top_size() const {
  return top_.size();
}
inline void LayerParameter::clear_top() {
  top_.Clear();
}
inline const ::std::string& LayerParameter::top(int index) const {
  return top_.Get(index);
}
inline ::std::string* LayerParameter::mutable_top(int index) {
  return top_.Mutable(index);
}
inline void LayerParameter::set_top(int index, const ::std::string& value) {
  top_.Mutable(index)->assign(value);
}
inline void LayerParameter::set_top(int index, const char* value) {
  top_.Mutable(index)->assign(value);
}
inline void LayerParameter::set_top(int index, const char* value, size_t size) {
  top_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerParameter::add_top() {
  return top_.Add();
}
inline void LayerParameter::add_top(const ::std::string& value) {
  top_.Add()->assign(value);
}
inline void LayerParameter::add_top(const char* value) {
  top_.Add()->assign(value);
}
inline void LayerParameter::add_top(const char* value, size_t size) {
  top_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerParameter::top() const {
  return top_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerParameter::mutable_top() {
  return &top_;
}

// optional string name = 4;
inline bool LayerParameter::has_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LayerParameter::set_has_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LayerParameter::clear_has_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LayerParameter::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& LayerParameter::name() const {
  return *name_;
}
inline void LayerParameter::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void LayerParameter::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void LayerParameter::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerParameter::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* LayerParameter::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LayerParameter::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated .caffe.NetStateRule include = 32;
inline int LayerParameter::include_size() const {
  return include_.size();
}
inline void LayerParameter::clear_include() {
  include_.Clear();
}
inline const ::caffe::NetStateRule& LayerParameter::include(int index) const {
  return include_.Get(index);
}
inline ::caffe::NetStateRule* LayerParameter::mutable_include(int index) {
  return include_.Mutable(index);
}
inline ::caffe::NetStateRule* LayerParameter::add_include() {
  return include_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >&
LayerParameter::include() const {
  return include_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >*
LayerParameter::mutable_include() {
  return &include_;
}

// repeated .caffe.NetStateRule exclude = 33;
inline int LayerParameter::exclude_size() const {
  return exclude_.size();
}
inline void LayerParameter::clear_exclude() {
  exclude_.Clear();
}
inline const ::caffe::NetStateRule& LayerParameter::exclude(int index) const {
  return exclude_.Get(index);
}
inline ::caffe::NetStateRule* LayerParameter::mutable_exclude(int index) {
  return exclude_.Mutable(index);
}
inline ::caffe::NetStateRule* LayerParameter::add_exclude() {
  return exclude_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >&
LayerParameter::exclude() const {
  return exclude_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::NetStateRule >*
LayerParameter::mutable_exclude() {
  return &exclude_;
}

// optional .caffe.LayerParameter.LayerType type = 5;
inline bool LayerParameter::has_type() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LayerParameter::set_has_type() {
  _has_bits_[0] |= 0x00000020u;
}
inline void LayerParameter::clear_has_type() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void LayerParameter::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::caffe::LayerParameter_LayerType LayerParameter::type() const {
  return static_cast< ::caffe::LayerParameter_LayerType >(type_);
}
inline void LayerParameter::set_type(::caffe::LayerParameter_LayerType value) {
  assert(::caffe::LayerParameter_LayerType_IsValid(value));
  set_has_type();
  type_ = value;
}

// repeated .caffe.BlobProto blobs = 6;
inline int LayerParameter::blobs_size() const {
  return blobs_.size();
}
inline void LayerParameter::clear_blobs() {
  blobs_.Clear();
}
inline const ::caffe::BlobProto& LayerParameter::blobs(int index) const {
  return blobs_.Get(index);
}
inline ::caffe::BlobProto* LayerParameter::mutable_blobs(int index) {
  return blobs_.Mutable(index);
}
inline ::caffe::BlobProto* LayerParameter::add_blobs() {
  return blobs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
LayerParameter::blobs() const {
  return blobs_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
LayerParameter::mutable_blobs() {
  return &blobs_;
}

// repeated string param = 1001;
inline int LayerParameter::param_size() const {
  return param_.size();
}
inline void LayerParameter::clear_param() {
  param_.Clear();
}
inline const ::std::string& LayerParameter::param(int index) const {
  return param_.Get(index);
}
inline ::std::string* LayerParameter::mutable_param(int index) {
  return param_.Mutable(index);
}
inline void LayerParameter::set_param(int index, const ::std::string& value) {
  param_.Mutable(index)->assign(value);
}
inline void LayerParameter::set_param(int index, const char* value) {
  param_.Mutable(index)->assign(value);
}
inline void LayerParameter::set_param(int index, const char* value, size_t size) {
  param_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LayerParameter::add_param() {
  return param_.Add();
}
inline void LayerParameter::add_param(const ::std::string& value) {
  param_.Add()->assign(value);
}
inline void LayerParameter::add_param(const char* value) {
  param_.Add()->assign(value);
}
inline void LayerParameter::add_param(const char* value, size_t size) {
  param_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
LayerParameter::param() const {
  return param_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
LayerParameter::mutable_param() {
  return &param_;
}

// repeated .caffe.LayerParameter.DimCheckMode blob_share_mode = 1002;
inline int LayerParameter::blob_share_mode_size() const {
  return blob_share_mode_.size();
}
inline void LayerParameter::clear_blob_share_mode() {
  blob_share_mode_.Clear();
}
inline ::caffe::LayerParameter_DimCheckMode LayerParameter::blob_share_mode(int index) const {
  return static_cast< ::caffe::LayerParameter_DimCheckMode >(blob_share_mode_.Get(index));
}
inline void LayerParameter::set_blob_share_mode(int index, ::caffe::LayerParameter_DimCheckMode value) {
  assert(::caffe::LayerParameter_DimCheckMode_IsValid(value));
  blob_share_mode_.Set(index, value);
}
inline void LayerParameter::add_blob_share_mode(::caffe::LayerParameter_DimCheckMode value) {
  assert(::caffe::LayerParameter_DimCheckMode_IsValid(value));
  blob_share_mode_.Add(value);
}
inline const ::google::protobuf::RepeatedField<int>&
LayerParameter::blob_share_mode() const {
  return blob_share_mode_;
}
inline ::google::protobuf::RepeatedField<int>*
LayerParameter::mutable_blob_share_mode() {
  return &blob_share_mode_;
}

// repeated float blobs_lr = 7;
inline int LayerParameter::blobs_lr_size() const {
  return blobs_lr_.size();
}
inline void LayerParameter::clear_blobs_lr() {
  blobs_lr_.Clear();
}
inline float LayerParameter::blobs_lr(int index) const {
  return blobs_lr_.Get(index);
}
inline void LayerParameter::set_blobs_lr(int index, float value) {
  blobs_lr_.Set(index, value);
}
inline void LayerParameter::add_blobs_lr(float value) {
  blobs_lr_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
LayerParameter::blobs_lr() const {
  return blobs_lr_;
}
inline ::google::protobuf::RepeatedField< float >*
LayerParameter::mutable_blobs_lr() {
  return &blobs_lr_;
}

// repeated float weight_decay = 8;
inline int LayerParameter::weight_decay_size() const {
  return weight_decay_.size();
}
inline void LayerParameter::clear_weight_decay() {
  weight_decay_.Clear();
}
inline float LayerParameter::weight_decay(int index) const {
  return weight_decay_.Get(index);
}
inline void LayerParameter::set_weight_decay(int index, float value) {
  weight_decay_.Set(index, value);
}
inline void LayerParameter::add_weight_decay(float value) {
  weight_decay_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
LayerParameter::weight_decay() const {
  return weight_decay_;
}
inline ::google::protobuf::RepeatedField< float >*
LayerParameter::mutable_weight_decay() {
  return &weight_decay_;
}

// repeated float loss_weight = 35;
inline int LayerParameter::loss_weight_size() const {
  return loss_weight_.size();
}
inline void LayerParameter::clear_loss_weight() {
  loss_weight_.Clear();
}
inline float LayerParameter::loss_weight(int index) const {
  return loss_weight_.Get(index);
}
inline void LayerParameter::set_loss_weight(int index, float value) {
  loss_weight_.Set(index, value);
}
inline void LayerParameter::add_loss_weight(float value) {
  loss_weight_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
LayerParameter::loss_weight() const {
  return loss_weight_;
}
inline ::google::protobuf::RepeatedField< float >*
LayerParameter::mutable_loss_weight() {
  return &loss_weight_;
}

// optional .caffe.AccuracyParameter accuracy_param = 27;
inline bool LayerParameter::has_accuracy_param() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void LayerParameter::set_has_accuracy_param() {
  _has_bits_[0] |= 0x00001000u;
}
inline void LayerParameter::clear_has_accuracy_param() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void LayerParameter::clear_accuracy_param() {
  if (accuracy_param_ != NULL) accuracy_param_->::caffe::AccuracyParameter::Clear();
  clear_has_accuracy_param();
}
inline const ::caffe::AccuracyParameter& LayerParameter::accuracy_param() const {
  return accuracy_param_ != NULL ? *accuracy_param_ : *default_instance_->accuracy_param_;
}
inline ::caffe::AccuracyParameter* LayerParameter::mutable_accuracy_param() {
  set_has_accuracy_param();
  if (accuracy_param_ == NULL) accuracy_param_ = new ::caffe::AccuracyParameter;
  return accuracy_param_;
}
inline ::caffe::AccuracyParameter* LayerParameter::release_accuracy_param() {
  clear_has_accuracy_param();
  ::caffe::AccuracyParameter* temp = accuracy_param_;
  accuracy_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_accuracy_param(::caffe::AccuracyParameter* accuracy_param) {
  delete accuracy_param_;
  accuracy_param_ = accuracy_param;
  if (accuracy_param) {
    set_has_accuracy_param();
  } else {
    clear_has_accuracy_param();
  }
}

// optional .caffe.ArgMaxParameter argmax_param = 23;
inline bool LayerParameter::has_argmax_param() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void LayerParameter::set_has_argmax_param() {
  _has_bits_[0] |= 0x00002000u;
}
inline void LayerParameter::clear_has_argmax_param() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void LayerParameter::clear_argmax_param() {
  if (argmax_param_ != NULL) argmax_param_->::caffe::ArgMaxParameter::Clear();
  clear_has_argmax_param();
}
inline const ::caffe::ArgMaxParameter& LayerParameter::argmax_param() const {
  return argmax_param_ != NULL ? *argmax_param_ : *default_instance_->argmax_param_;
}
inline ::caffe::ArgMaxParameter* LayerParameter::mutable_argmax_param() {
  set_has_argmax_param();
  if (argmax_param_ == NULL) argmax_param_ = new ::caffe::ArgMaxParameter;
  return argmax_param_;
}
inline ::caffe::ArgMaxParameter* LayerParameter::release_argmax_param() {
  clear_has_argmax_param();
  ::caffe::ArgMaxParameter* temp = argmax_param_;
  argmax_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_argmax_param(::caffe::ArgMaxParameter* argmax_param) {
  delete argmax_param_;
  argmax_param_ = argmax_param;
  if (argmax_param) {
    set_has_argmax_param();
  } else {
    clear_has_argmax_param();
  }
}

// optional .caffe.ConcatParameter concat_param = 9;
inline bool LayerParameter::has_concat_param() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void LayerParameter::set_has_concat_param() {
  _has_bits_[0] |= 0x00004000u;
}
inline void LayerParameter::clear_has_concat_param() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void LayerParameter::clear_concat_param() {
  if (concat_param_ != NULL) concat_param_->::caffe::ConcatParameter::Clear();
  clear_has_concat_param();
}
inline const ::caffe::ConcatParameter& LayerParameter::concat_param() const {
  return concat_param_ != NULL ? *concat_param_ : *default_instance_->concat_param_;
}
inline ::caffe::ConcatParameter* LayerParameter::mutable_concat_param() {
  set_has_concat_param();
  if (concat_param_ == NULL) concat_param_ = new ::caffe::ConcatParameter;
  return concat_param_;
}
inline ::caffe::ConcatParameter* LayerParameter::release_concat_param() {
  clear_has_concat_param();
  ::caffe::ConcatParameter* temp = concat_param_;
  concat_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_concat_param(::caffe::ConcatParameter* concat_param) {
  delete concat_param_;
  concat_param_ = concat_param;
  if (concat_param) {
    set_has_concat_param();
  } else {
    clear_has_concat_param();
  }
}

// optional .caffe.ContrastiveLossParameter contrastive_loss_param = 40;
inline bool LayerParameter::has_contrastive_loss_param() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void LayerParameter::set_has_contrastive_loss_param() {
  _has_bits_[0] |= 0x00008000u;
}
inline void LayerParameter::clear_has_contrastive_loss_param() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void LayerParameter::clear_contrastive_loss_param() {
  if (contrastive_loss_param_ != NULL) contrastive_loss_param_->::caffe::ContrastiveLossParameter::Clear();
  clear_has_contrastive_loss_param();
}
inline const ::caffe::ContrastiveLossParameter& LayerParameter::contrastive_loss_param() const {
  return contrastive_loss_param_ != NULL ? *contrastive_loss_param_ : *default_instance_->contrastive_loss_param_;
}
inline ::caffe::ContrastiveLossParameter* LayerParameter::mutable_contrastive_loss_param() {
  set_has_contrastive_loss_param();
  if (contrastive_loss_param_ == NULL) contrastive_loss_param_ = new ::caffe::ContrastiveLossParameter;
  return contrastive_loss_param_;
}
inline ::caffe::ContrastiveLossParameter* LayerParameter::release_contrastive_loss_param() {
  clear_has_contrastive_loss_param();
  ::caffe::ContrastiveLossParameter* temp = contrastive_loss_param_;
  contrastive_loss_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_contrastive_loss_param(::caffe::ContrastiveLossParameter* contrastive_loss_param) {
  delete contrastive_loss_param_;
  contrastive_loss_param_ = contrastive_loss_param;
  if (contrastive_loss_param) {
    set_has_contrastive_loss_param();
  } else {
    clear_has_contrastive_loss_param();
  }
}

// optional .caffe.ConvolutionParameter convolution_param = 10;
inline bool LayerParameter::has_convolution_param() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void LayerParameter::set_has_convolution_param() {
  _has_bits_[0] |= 0x00010000u;
}
inline void LayerParameter::clear_has_convolution_param() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void LayerParameter::clear_convolution_param() {
  if (convolution_param_ != NULL) convolution_param_->::caffe::ConvolutionParameter::Clear();
  clear_has_convolution_param();
}
inline const ::caffe::ConvolutionParameter& LayerParameter::convolution_param() const {
  return convolution_param_ != NULL ? *convolution_param_ : *default_instance_->convolution_param_;
}
inline ::caffe::ConvolutionParameter* LayerParameter::mutable_convolution_param() {
  set_has_convolution_param();
  if (convolution_param_ == NULL) convolution_param_ = new ::caffe::ConvolutionParameter;
  return convolution_param_;
}
inline ::caffe::ConvolutionParameter* LayerParameter::release_convolution_param() {
  clear_has_convolution_param();
  ::caffe::ConvolutionParameter* temp = convolution_param_;
  convolution_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_convolution_param(::caffe::ConvolutionParameter* convolution_param) {
  delete convolution_param_;
  convolution_param_ = convolution_param;
  if (convolution_param) {
    set_has_convolution_param();
  } else {
    clear_has_convolution_param();
  }
}

// optional .caffe.DataParameter data_param = 11;
inline bool LayerParameter::has_data_param() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void LayerParameter::set_has_data_param() {
  _has_bits_[0] |= 0x00020000u;
}
inline void LayerParameter::clear_has_data_param() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void LayerParameter::clear_data_param() {
  if (data_param_ != NULL) data_param_->::caffe::DataParameter::Clear();
  clear_has_data_param();
}
inline const ::caffe::DataParameter& LayerParameter::data_param() const {
  return data_param_ != NULL ? *data_param_ : *default_instance_->data_param_;
}
inline ::caffe::DataParameter* LayerParameter::mutable_data_param() {
  set_has_data_param();
  if (data_param_ == NULL) data_param_ = new ::caffe::DataParameter;
  return data_param_;
}
inline ::caffe::DataParameter* LayerParameter::release_data_param() {
  clear_has_data_param();
  ::caffe::DataParameter* temp = data_param_;
  data_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_data_param(::caffe::DataParameter* data_param) {
  delete data_param_;
  data_param_ = data_param;
  if (data_param) {
    set_has_data_param();
  } else {
    clear_has_data_param();
  }
}

// optional .caffe.DropoutParameter dropout_param = 12;
inline bool LayerParameter::has_dropout_param() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void LayerParameter::set_has_dropout_param() {
  _has_bits_[0] |= 0x00040000u;
}
inline void LayerParameter::clear_has_dropout_param() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void LayerParameter::clear_dropout_param() {
  if (dropout_param_ != NULL) dropout_param_->::caffe::DropoutParameter::Clear();
  clear_has_dropout_param();
}
inline const ::caffe::DropoutParameter& LayerParameter::dropout_param() const {
  return dropout_param_ != NULL ? *dropout_param_ : *default_instance_->dropout_param_;
}
inline ::caffe::DropoutParameter* LayerParameter::mutable_dropout_param() {
  set_has_dropout_param();
  if (dropout_param_ == NULL) dropout_param_ = new ::caffe::DropoutParameter;
  return dropout_param_;
}
inline ::caffe::DropoutParameter* LayerParameter::release_dropout_param() {
  clear_has_dropout_param();
  ::caffe::DropoutParameter* temp = dropout_param_;
  dropout_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_dropout_param(::caffe::DropoutParameter* dropout_param) {
  delete dropout_param_;
  dropout_param_ = dropout_param;
  if (dropout_param) {
    set_has_dropout_param();
  } else {
    clear_has_dropout_param();
  }
}

// optional .caffe.DummyDataParameter dummy_data_param = 26;
inline bool LayerParameter::has_dummy_data_param() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void LayerParameter::set_has_dummy_data_param() {
  _has_bits_[0] |= 0x00080000u;
}
inline void LayerParameter::clear_has_dummy_data_param() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void LayerParameter::clear_dummy_data_param() {
  if (dummy_data_param_ != NULL) dummy_data_param_->::caffe::DummyDataParameter::Clear();
  clear_has_dummy_data_param();
}
inline const ::caffe::DummyDataParameter& LayerParameter::dummy_data_param() const {
  return dummy_data_param_ != NULL ? *dummy_data_param_ : *default_instance_->dummy_data_param_;
}
inline ::caffe::DummyDataParameter* LayerParameter::mutable_dummy_data_param() {
  set_has_dummy_data_param();
  if (dummy_data_param_ == NULL) dummy_data_param_ = new ::caffe::DummyDataParameter;
  return dummy_data_param_;
}
inline ::caffe::DummyDataParameter* LayerParameter::release_dummy_data_param() {
  clear_has_dummy_data_param();
  ::caffe::DummyDataParameter* temp = dummy_data_param_;
  dummy_data_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_dummy_data_param(::caffe::DummyDataParameter* dummy_data_param) {
  delete dummy_data_param_;
  dummy_data_param_ = dummy_data_param;
  if (dummy_data_param) {
    set_has_dummy_data_param();
  } else {
    clear_has_dummy_data_param();
  }
}

// optional .caffe.EltwiseParameter eltwise_param = 24;
inline bool LayerParameter::has_eltwise_param() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void LayerParameter::set_has_eltwise_param() {
  _has_bits_[0] |= 0x00100000u;
}
inline void LayerParameter::clear_has_eltwise_param() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void LayerParameter::clear_eltwise_param() {
  if (eltwise_param_ != NULL) eltwise_param_->::caffe::EltwiseParameter::Clear();
  clear_has_eltwise_param();
}
inline const ::caffe::EltwiseParameter& LayerParameter::eltwise_param() const {
  return eltwise_param_ != NULL ? *eltwise_param_ : *default_instance_->eltwise_param_;
}
inline ::caffe::EltwiseParameter* LayerParameter::mutable_eltwise_param() {
  set_has_eltwise_param();
  if (eltwise_param_ == NULL) eltwise_param_ = new ::caffe::EltwiseParameter;
  return eltwise_param_;
}
inline ::caffe::EltwiseParameter* LayerParameter::release_eltwise_param() {
  clear_has_eltwise_param();
  ::caffe::EltwiseParameter* temp = eltwise_param_;
  eltwise_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_eltwise_param(::caffe::EltwiseParameter* eltwise_param) {
  delete eltwise_param_;
  eltwise_param_ = eltwise_param;
  if (eltwise_param) {
    set_has_eltwise_param();
  } else {
    clear_has_eltwise_param();
  }
}

// optional .caffe.ExpParameter exp_param = 41;
inline bool LayerParameter::has_exp_param() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void LayerParameter::set_has_exp_param() {
  _has_bits_[0] |= 0x00200000u;
}
inline void LayerParameter::clear_has_exp_param() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void LayerParameter::clear_exp_param() {
  if (exp_param_ != NULL) exp_param_->::caffe::ExpParameter::Clear();
  clear_has_exp_param();
}
inline const ::caffe::ExpParameter& LayerParameter::exp_param() const {
  return exp_param_ != NULL ? *exp_param_ : *default_instance_->exp_param_;
}
inline ::caffe::ExpParameter* LayerParameter::mutable_exp_param() {
  set_has_exp_param();
  if (exp_param_ == NULL) exp_param_ = new ::caffe::ExpParameter;
  return exp_param_;
}
inline ::caffe::ExpParameter* LayerParameter::release_exp_param() {
  clear_has_exp_param();
  ::caffe::ExpParameter* temp = exp_param_;
  exp_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_exp_param(::caffe::ExpParameter* exp_param) {
  delete exp_param_;
  exp_param_ = exp_param;
  if (exp_param) {
    set_has_exp_param();
  } else {
    clear_has_exp_param();
  }
}

// optional .caffe.HDF5DataParameter hdf5_data_param = 13;
inline bool LayerParameter::has_hdf5_data_param() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void LayerParameter::set_has_hdf5_data_param() {
  _has_bits_[0] |= 0x00400000u;
}
inline void LayerParameter::clear_has_hdf5_data_param() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void LayerParameter::clear_hdf5_data_param() {
  if (hdf5_data_param_ != NULL) hdf5_data_param_->::caffe::HDF5DataParameter::Clear();
  clear_has_hdf5_data_param();
}
inline const ::caffe::HDF5DataParameter& LayerParameter::hdf5_data_param() const {
  return hdf5_data_param_ != NULL ? *hdf5_data_param_ : *default_instance_->hdf5_data_param_;
}
inline ::caffe::HDF5DataParameter* LayerParameter::mutable_hdf5_data_param() {
  set_has_hdf5_data_param();
  if (hdf5_data_param_ == NULL) hdf5_data_param_ = new ::caffe::HDF5DataParameter;
  return hdf5_data_param_;
}
inline ::caffe::HDF5DataParameter* LayerParameter::release_hdf5_data_param() {
  clear_has_hdf5_data_param();
  ::caffe::HDF5DataParameter* temp = hdf5_data_param_;
  hdf5_data_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_hdf5_data_param(::caffe::HDF5DataParameter* hdf5_data_param) {
  delete hdf5_data_param_;
  hdf5_data_param_ = hdf5_data_param;
  if (hdf5_data_param) {
    set_has_hdf5_data_param();
  } else {
    clear_has_hdf5_data_param();
  }
}

// optional .caffe.HDF5OutputParameter hdf5_output_param = 14;
inline bool LayerParameter::has_hdf5_output_param() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void LayerParameter::set_has_hdf5_output_param() {
  _has_bits_[0] |= 0x00800000u;
}
inline void LayerParameter::clear_has_hdf5_output_param() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void LayerParameter::clear_hdf5_output_param() {
  if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear();
  clear_has_hdf5_output_param();
}
inline const ::caffe::HDF5OutputParameter& LayerParameter::hdf5_output_param() const {
  return hdf5_output_param_ != NULL ? *hdf5_output_param_ : *default_instance_->hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* LayerParameter::mutable_hdf5_output_param() {
  set_has_hdf5_output_param();
  if (hdf5_output_param_ == NULL) hdf5_output_param_ = new ::caffe::HDF5OutputParameter;
  return hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* LayerParameter::release_hdf5_output_param() {
  clear_has_hdf5_output_param();
  ::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
  hdf5_output_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) {
  delete hdf5_output_param_;
  hdf5_output_param_ = hdf5_output_param;
  if (hdf5_output_param) {
    set_has_hdf5_output_param();
  } else {
    clear_has_hdf5_output_param();
  }
}

// optional .caffe.HingeLossParameter hinge_loss_param = 29;
inline bool LayerParameter::has_hinge_loss_param() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void LayerParameter::set_has_hinge_loss_param() {
  _has_bits_[0] |= 0x01000000u;
}
inline void LayerParameter::clear_has_hinge_loss_param() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void LayerParameter::clear_hinge_loss_param() {
  if (hinge_loss_param_ != NULL) hinge_loss_param_->::caffe::HingeLossParameter::Clear();
  clear_has_hinge_loss_param();
}
inline const ::caffe::HingeLossParameter& LayerParameter::hinge_loss_param() const {
  return hinge_loss_param_ != NULL ? *hinge_loss_param_ : *default_instance_->hinge_loss_param_;
}
inline ::caffe::HingeLossParameter* LayerParameter::mutable_hinge_loss_param() {
  set_has_hinge_loss_param();
  if (hinge_loss_param_ == NULL) hinge_loss_param_ = new ::caffe::HingeLossParameter;
  return hinge_loss_param_;
}
inline ::caffe::HingeLossParameter* LayerParameter::release_hinge_loss_param() {
  clear_has_hinge_loss_param();
  ::caffe::HingeLossParameter* temp = hinge_loss_param_;
  hinge_loss_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_hinge_loss_param(::caffe::HingeLossParameter* hinge_loss_param) {
  delete hinge_loss_param_;
  hinge_loss_param_ = hinge_loss_param;
  if (hinge_loss_param) {
    set_has_hinge_loss_param();
  } else {
    clear_has_hinge_loss_param();
  }
}

// optional .caffe.ImageDataParameter image_data_param = 15;
inline bool LayerParameter::has_image_data_param() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void LayerParameter::set_has_image_data_param() {
  _has_bits_[0] |= 0x02000000u;
}
inline void LayerParameter::clear_has_image_data_param() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void LayerParameter::clear_image_data_param() {
  if (image_data_param_ != NULL) image_data_param_->::caffe::ImageDataParameter::Clear();
  clear_has_image_data_param();
}
inline const ::caffe::ImageDataParameter& LayerParameter::image_data_param() const {
  return image_data_param_ != NULL ? *image_data_param_ : *default_instance_->image_data_param_;
}
inline ::caffe::ImageDataParameter* LayerParameter::mutable_image_data_param() {
  set_has_image_data_param();
  if (image_data_param_ == NULL) image_data_param_ = new ::caffe::ImageDataParameter;
  return image_data_param_;
}
inline ::caffe::ImageDataParameter* LayerParameter::release_image_data_param() {
  clear_has_image_data_param();
  ::caffe::ImageDataParameter* temp = image_data_param_;
  image_data_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_image_data_param(::caffe::ImageDataParameter* image_data_param) {
  delete image_data_param_;
  image_data_param_ = image_data_param;
  if (image_data_param) {
    set_has_image_data_param();
  } else {
    clear_has_image_data_param();
  }
}

// optional .caffe.InfogainLossParameter infogain_loss_param = 16;
inline bool LayerParameter::has_infogain_loss_param() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void LayerParameter::set_has_infogain_loss_param() {
  _has_bits_[0] |= 0x04000000u;
}
inline void LayerParameter::clear_has_infogain_loss_param() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void LayerParameter::clear_infogain_loss_param() {
  if (infogain_loss_param_ != NULL) infogain_loss_param_->::caffe::InfogainLossParameter::Clear();
  clear_has_infogain_loss_param();
}
inline const ::caffe::InfogainLossParameter& LayerParameter::infogain_loss_param() const {
  return infogain_loss_param_ != NULL ? *infogain_loss_param_ : *default_instance_->infogain_loss_param_;
}
inline ::caffe::InfogainLossParameter* LayerParameter::mutable_infogain_loss_param() {
  set_has_infogain_loss_param();
  if (infogain_loss_param_ == NULL) infogain_loss_param_ = new ::caffe::InfogainLossParameter;
  return infogain_loss_param_;
}
inline ::caffe::InfogainLossParameter* LayerParameter::release_infogain_loss_param() {
  clear_has_infogain_loss_param();
  ::caffe::InfogainLossParameter* temp = infogain_loss_param_;
  infogain_loss_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_infogain_loss_param(::caffe::InfogainLossParameter* infogain_loss_param) {
  delete infogain_loss_param_;
  infogain_loss_param_ = infogain_loss_param;
  if (infogain_loss_param) {
    set_has_infogain_loss_param();
  } else {
    clear_has_infogain_loss_param();
  }
}

// optional .caffe.InnerProductParameter inner_product_param = 17;
inline bool LayerParameter::has_inner_product_param() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void LayerParameter::set_has_inner_product_param() {
  _has_bits_[0] |= 0x08000000u;
}
inline void LayerParameter::clear_has_inner_product_param() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void LayerParameter::clear_inner_product_param() {
  if (inner_product_param_ != NULL) inner_product_param_->::caffe::InnerProductParameter::Clear();
  clear_has_inner_product_param();
}
inline const ::caffe::InnerProductParameter& LayerParameter::inner_product_param() const {
  return inner_product_param_ != NULL ? *inner_product_param_ : *default_instance_->inner_product_param_;
}
inline ::caffe::InnerProductParameter* LayerParameter::mutable_inner_product_param() {
  set_has_inner_product_param();
  if (inner_product_param_ == NULL) inner_product_param_ = new ::caffe::InnerProductParameter;
  return inner_product_param_;
}
inline ::caffe::InnerProductParameter* LayerParameter::release_inner_product_param() {
  clear_has_inner_product_param();
  ::caffe::InnerProductParameter* temp = inner_product_param_;
  inner_product_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_inner_product_param(::caffe::InnerProductParameter* inner_product_param) {
  delete inner_product_param_;
  inner_product_param_ = inner_product_param;
  if (inner_product_param) {
    set_has_inner_product_param();
  } else {
    clear_has_inner_product_param();
  }
}

// optional .caffe.LRNParameter lrn_param = 18;
inline bool LayerParameter::has_lrn_param() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void LayerParameter::set_has_lrn_param() {
  _has_bits_[0] |= 0x10000000u;
}
inline void LayerParameter::clear_has_lrn_param() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void LayerParameter::clear_lrn_param() {
  if (lrn_param_ != NULL) lrn_param_->::caffe::LRNParameter::Clear();
  clear_has_lrn_param();
}
inline const ::caffe::LRNParameter& LayerParameter::lrn_param() const {
  return lrn_param_ != NULL ? *lrn_param_ : *default_instance_->lrn_param_;
}
inline ::caffe::LRNParameter* LayerParameter::mutable_lrn_param() {
  set_has_lrn_param();
  if (lrn_param_ == NULL) lrn_param_ = new ::caffe::LRNParameter;
  return lrn_param_;
}
inline ::caffe::LRNParameter* LayerParameter::release_lrn_param() {
  clear_has_lrn_param();
  ::caffe::LRNParameter* temp = lrn_param_;
  lrn_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_lrn_param(::caffe::LRNParameter* lrn_param) {
  delete lrn_param_;
  lrn_param_ = lrn_param;
  if (lrn_param) {
    set_has_lrn_param();
  } else {
    clear_has_lrn_param();
  }
}

// optional .caffe.MultiStageMeanfieldParameter multi_stage_meanfield_param = 44;
inline bool LayerParameter::has_multi_stage_meanfield_param() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void LayerParameter::set_has_multi_stage_meanfield_param() {
  _has_bits_[0] |= 0x20000000u;
}
inline void LayerParameter::clear_has_multi_stage_meanfield_param() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void LayerParameter::clear_multi_stage_meanfield_param() {
  if (multi_stage_meanfield_param_ != NULL) multi_stage_meanfield_param_->::caffe::MultiStageMeanfieldParameter::Clear();
  clear_has_multi_stage_meanfield_param();
}
inline const ::caffe::MultiStageMeanfieldParameter& LayerParameter::multi_stage_meanfield_param() const {
  return multi_stage_meanfield_param_ != NULL ? *multi_stage_meanfield_param_ : *default_instance_->multi_stage_meanfield_param_;
}
inline ::caffe::MultiStageMeanfieldParameter* LayerParameter::mutable_multi_stage_meanfield_param() {
  set_has_multi_stage_meanfield_param();
  if (multi_stage_meanfield_param_ == NULL) multi_stage_meanfield_param_ = new ::caffe::MultiStageMeanfieldParameter;
  return multi_stage_meanfield_param_;
}
inline ::caffe::MultiStageMeanfieldParameter* LayerParameter::release_multi_stage_meanfield_param() {
  clear_has_multi_stage_meanfield_param();
  ::caffe::MultiStageMeanfieldParameter* temp = multi_stage_meanfield_param_;
  multi_stage_meanfield_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_multi_stage_meanfield_param(::caffe::MultiStageMeanfieldParameter* multi_stage_meanfield_param) {
  delete multi_stage_meanfield_param_;
  multi_stage_meanfield_param_ = multi_stage_meanfield_param;
  if (multi_stage_meanfield_param) {
    set_has_multi_stage_meanfield_param();
  } else {
    clear_has_multi_stage_meanfield_param();
  }
}

// optional .caffe.MemoryDataParameter memory_data_param = 22;
inline bool LayerParameter::has_memory_data_param() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void LayerParameter::set_has_memory_data_param() {
  _has_bits_[0] |= 0x40000000u;
}
inline void LayerParameter::clear_has_memory_data_param() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void LayerParameter::clear_memory_data_param() {
  if (memory_data_param_ != NULL) memory_data_param_->::caffe::MemoryDataParameter::Clear();
  clear_has_memory_data_param();
}
inline const ::caffe::MemoryDataParameter& LayerParameter::memory_data_param() const {
  return memory_data_param_ != NULL ? *memory_data_param_ : *default_instance_->memory_data_param_;
}
inline ::caffe::MemoryDataParameter* LayerParameter::mutable_memory_data_param() {
  set_has_memory_data_param();
  if (memory_data_param_ == NULL) memory_data_param_ = new ::caffe::MemoryDataParameter;
  return memory_data_param_;
}
inline ::caffe::MemoryDataParameter* LayerParameter::release_memory_data_param() {
  clear_has_memory_data_param();
  ::caffe::MemoryDataParameter* temp = memory_data_param_;
  memory_data_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_memory_data_param(::caffe::MemoryDataParameter* memory_data_param) {
  delete memory_data_param_;
  memory_data_param_ = memory_data_param;
  if (memory_data_param) {
    set_has_memory_data_param();
  } else {
    clear_has_memory_data_param();
  }
}

// optional .caffe.MVNParameter mvn_param = 34;
inline bool LayerParameter::has_mvn_param() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void LayerParameter::set_has_mvn_param() {
  _has_bits_[0] |= 0x80000000u;
}
inline void LayerParameter::clear_has_mvn_param() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void LayerParameter::clear_mvn_param() {
  if (mvn_param_ != NULL) mvn_param_->::caffe::MVNParameter::Clear();
  clear_has_mvn_param();
}
inline const ::caffe::MVNParameter& LayerParameter::mvn_param() const {
  return mvn_param_ != NULL ? *mvn_param_ : *default_instance_->mvn_param_;
}
inline ::caffe::MVNParameter* LayerParameter::mutable_mvn_param() {
  set_has_mvn_param();
  if (mvn_param_ == NULL) mvn_param_ = new ::caffe::MVNParameter;
  return mvn_param_;
}
inline ::caffe::MVNParameter* LayerParameter::release_mvn_param() {
  clear_has_mvn_param();
  ::caffe::MVNParameter* temp = mvn_param_;
  mvn_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_mvn_param(::caffe::MVNParameter* mvn_param) {
  delete mvn_param_;
  mvn_param_ = mvn_param;
  if (mvn_param) {
    set_has_mvn_param();
  } else {
    clear_has_mvn_param();
  }
}

// optional .caffe.PoolingParameter pooling_param = 19;
inline bool LayerParameter::has_pooling_param() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void LayerParameter::set_has_pooling_param() {
  _has_bits_[1] |= 0x00000001u;
}
inline void LayerParameter::clear_has_pooling_param() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void LayerParameter::clear_pooling_param() {
  if (pooling_param_ != NULL) pooling_param_->::caffe::PoolingParameter::Clear();
  clear_has_pooling_param();
}
inline const ::caffe::PoolingParameter& LayerParameter::pooling_param() const {
  return pooling_param_ != NULL ? *pooling_param_ : *default_instance_->pooling_param_;
}
inline ::caffe::PoolingParameter* LayerParameter::mutable_pooling_param() {
  set_has_pooling_param();
  if (pooling_param_ == NULL) pooling_param_ = new ::caffe::PoolingParameter;
  return pooling_param_;
}
inline ::caffe::PoolingParameter* LayerParameter::release_pooling_param() {
  clear_has_pooling_param();
  ::caffe::PoolingParameter* temp = pooling_param_;
  pooling_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_pooling_param(::caffe::PoolingParameter* pooling_param) {
  delete pooling_param_;
  pooling_param_ = pooling_param;
  if (pooling_param) {
    set_has_pooling_param();
  } else {
    clear_has_pooling_param();
  }
}

// optional .caffe.PowerParameter power_param = 21;
inline bool LayerParameter::has_power_param() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void LayerParameter::set_has_power_param() {
  _has_bits_[1] |= 0x00000002u;
}
inline void LayerParameter::clear_has_power_param() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void LayerParameter::clear_power_param() {
  if (power_param_ != NULL) power_param_->::caffe::PowerParameter::Clear();
  clear_has_power_param();
}
inline const ::caffe::PowerParameter& LayerParameter::power_param() const {
  return power_param_ != NULL ? *power_param_ : *default_instance_->power_param_;
}
inline ::caffe::PowerParameter* LayerParameter::mutable_power_param() {
  set_has_power_param();
  if (power_param_ == NULL) power_param_ = new ::caffe::PowerParameter;
  return power_param_;
}
inline ::caffe::PowerParameter* LayerParameter::release_power_param() {
  clear_has_power_param();
  ::caffe::PowerParameter* temp = power_param_;
  power_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_power_param(::caffe::PowerParameter* power_param) {
  delete power_param_;
  power_param_ = power_param;
  if (power_param) {
    set_has_power_param();
  } else {
    clear_has_power_param();
  }
}

// optional .caffe.ReLUParameter relu_param = 30;
inline bool LayerParameter::has_relu_param() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void LayerParameter::set_has_relu_param() {
  _has_bits_[1] |= 0x00000004u;
}
inline void LayerParameter::clear_has_relu_param() {
  _has_bits_[1] &= ~0x00000004u;
}
inline void LayerParameter::clear_relu_param() {
  if (relu_param_ != NULL) relu_param_->::caffe::ReLUParameter::Clear();
  clear_has_relu_param();
}
inline const ::caffe::ReLUParameter& LayerParameter::relu_param() const {
  return relu_param_ != NULL ? *relu_param_ : *default_instance_->relu_param_;
}
inline ::caffe::ReLUParameter* LayerParameter::mutable_relu_param() {
  set_has_relu_param();
  if (relu_param_ == NULL) relu_param_ = new ::caffe::ReLUParameter;
  return relu_param_;
}
inline ::caffe::ReLUParameter* LayerParameter::release_relu_param() {
  clear_has_relu_param();
  ::caffe::ReLUParameter* temp = relu_param_;
  relu_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_relu_param(::caffe::ReLUParameter* relu_param) {
  delete relu_param_;
  relu_param_ = relu_param;
  if (relu_param) {
    set_has_relu_param();
  } else {
    clear_has_relu_param();
  }
}

// optional .caffe.SigmoidParameter sigmoid_param = 38;
inline bool LayerParameter::has_sigmoid_param() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void LayerParameter::set_has_sigmoid_param() {
  _has_bits_[1] |= 0x00000008u;
}
inline void LayerParameter::clear_has_sigmoid_param() {
  _has_bits_[1] &= ~0x00000008u;
}
inline void LayerParameter::clear_sigmoid_param() {
  if (sigmoid_param_ != NULL) sigmoid_param_->::caffe::SigmoidParameter::Clear();
  clear_has_sigmoid_param();
}
inline const ::caffe::SigmoidParameter& LayerParameter::sigmoid_param() const {
  return sigmoid_param_ != NULL ? *sigmoid_param_ : *default_instance_->sigmoid_param_;
}
inline ::caffe::SigmoidParameter* LayerParameter::mutable_sigmoid_param() {
  set_has_sigmoid_param();
  if (sigmoid_param_ == NULL) sigmoid_param_ = new ::caffe::SigmoidParameter;
  return sigmoid_param_;
}
inline ::caffe::SigmoidParameter* LayerParameter::release_sigmoid_param() {
  clear_has_sigmoid_param();
  ::caffe::SigmoidParameter* temp = sigmoid_param_;
  sigmoid_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_sigmoid_param(::caffe::SigmoidParameter* sigmoid_param) {
  delete sigmoid_param_;
  sigmoid_param_ = sigmoid_param;
  if (sigmoid_param) {
    set_has_sigmoid_param();
  } else {
    clear_has_sigmoid_param();
  }
}

// optional .caffe.SoftmaxParameter softmax_param = 39;
inline bool LayerParameter::has_softmax_param() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void LayerParameter::set_has_softmax_param() {
  _has_bits_[1] |= 0x00000010u;
}
inline void LayerParameter::clear_has_softmax_param() {
  _has_bits_[1] &= ~0x00000010u;
}
inline void LayerParameter::clear_softmax_param() {
  if (softmax_param_ != NULL) softmax_param_->::caffe::SoftmaxParameter::Clear();
  clear_has_softmax_param();
}
inline const ::caffe::SoftmaxParameter& LayerParameter::softmax_param() const {
  return softmax_param_ != NULL ? *softmax_param_ : *default_instance_->softmax_param_;
}
inline ::caffe::SoftmaxParameter* LayerParameter::mutable_softmax_param() {
  set_has_softmax_param();
  if (softmax_param_ == NULL) softmax_param_ = new ::caffe::SoftmaxParameter;
  return softmax_param_;
}
inline ::caffe::SoftmaxParameter* LayerParameter::release_softmax_param() {
  clear_has_softmax_param();
  ::caffe::SoftmaxParameter* temp = softmax_param_;
  softmax_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_softmax_param(::caffe::SoftmaxParameter* softmax_param) {
  delete softmax_param_;
  softmax_param_ = softmax_param;
  if (softmax_param) {
    set_has_softmax_param();
  } else {
    clear_has_softmax_param();
  }
}

// optional .caffe.SliceParameter slice_param = 31;
inline bool LayerParameter::has_slice_param() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void LayerParameter::set_has_slice_param() {
  _has_bits_[1] |= 0x00000020u;
}
inline void LayerParameter::clear_has_slice_param() {
  _has_bits_[1] &= ~0x00000020u;
}
inline void LayerParameter::clear_slice_param() {
  if (slice_param_ != NULL) slice_param_->::caffe::SliceParameter::Clear();
  clear_has_slice_param();
}
inline const ::caffe::SliceParameter& LayerParameter::slice_param() const {
  return slice_param_ != NULL ? *slice_param_ : *default_instance_->slice_param_;
}
inline ::caffe::SliceParameter* LayerParameter::mutable_slice_param() {
  set_has_slice_param();
  if (slice_param_ == NULL) slice_param_ = new ::caffe::SliceParameter;
  return slice_param_;
}
inline ::caffe::SliceParameter* LayerParameter::release_slice_param() {
  clear_has_slice_param();
  ::caffe::SliceParameter* temp = slice_param_;
  slice_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_slice_param(::caffe::SliceParameter* slice_param) {
  delete slice_param_;
  slice_param_ = slice_param;
  if (slice_param) {
    set_has_slice_param();
  } else {
    clear_has_slice_param();
  }
}

// optional .caffe.TanHParameter tanh_param = 37;
inline bool LayerParameter::has_tanh_param() const {
  return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void LayerParameter::set_has_tanh_param() {
  _has_bits_[1] |= 0x00000040u;
}
inline void LayerParameter::clear_has_tanh_param() {
  _has_bits_[1] &= ~0x00000040u;
}
inline void LayerParameter::clear_tanh_param() {
  if (tanh_param_ != NULL) tanh_param_->::caffe::TanHParameter::Clear();
  clear_has_tanh_param();
}
inline const ::caffe::TanHParameter& LayerParameter::tanh_param() const {
  return tanh_param_ != NULL ? *tanh_param_ : *default_instance_->tanh_param_;
}
inline ::caffe::TanHParameter* LayerParameter::mutable_tanh_param() {
  set_has_tanh_param();
  if (tanh_param_ == NULL) tanh_param_ = new ::caffe::TanHParameter;
  return tanh_param_;
}
inline ::caffe::TanHParameter* LayerParameter::release_tanh_param() {
  clear_has_tanh_param();
  ::caffe::TanHParameter* temp = tanh_param_;
  tanh_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_tanh_param(::caffe::TanHParameter* tanh_param) {
  delete tanh_param_;
  tanh_param_ = tanh_param;
  if (tanh_param) {
    set_has_tanh_param();
  } else {
    clear_has_tanh_param();
  }
}

// optional .caffe.ThresholdParameter threshold_param = 25;
inline bool LayerParameter::has_threshold_param() const {
  return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void LayerParameter::set_has_threshold_param() {
  _has_bits_[1] |= 0x00000080u;
}
inline void LayerParameter::clear_has_threshold_param() {
  _has_bits_[1] &= ~0x00000080u;
}
inline void LayerParameter::clear_threshold_param() {
  if (threshold_param_ != NULL) threshold_param_->::caffe::ThresholdParameter::Clear();
  clear_has_threshold_param();
}
inline const ::caffe::ThresholdParameter& LayerParameter::threshold_param() const {
  return threshold_param_ != NULL ? *threshold_param_ : *default_instance_->threshold_param_;
}
inline ::caffe::ThresholdParameter* LayerParameter::mutable_threshold_param() {
  set_has_threshold_param();
  if (threshold_param_ == NULL) threshold_param_ = new ::caffe::ThresholdParameter;
  return threshold_param_;
}
inline ::caffe::ThresholdParameter* LayerParameter::release_threshold_param() {
  clear_has_threshold_param();
  ::caffe::ThresholdParameter* temp = threshold_param_;
  threshold_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_threshold_param(::caffe::ThresholdParameter* threshold_param) {
  delete threshold_param_;
  threshold_param_ = threshold_param;
  if (threshold_param) {
    set_has_threshold_param();
  } else {
    clear_has_threshold_param();
  }
}

// optional .caffe.WindowDataParameter window_data_param = 20;
inline bool LayerParameter::has_window_data_param() const {
  return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void LayerParameter::set_has_window_data_param() {
  _has_bits_[1] |= 0x00000100u;
}
inline void LayerParameter::clear_has_window_data_param() {
  _has_bits_[1] &= ~0x00000100u;
}
inline void LayerParameter::clear_window_data_param() {
  if (window_data_param_ != NULL) window_data_param_->::caffe::WindowDataParameter::Clear();
  clear_has_window_data_param();
}
inline const ::caffe::WindowDataParameter& LayerParameter::window_data_param() const {
  return window_data_param_ != NULL ? *window_data_param_ : *default_instance_->window_data_param_;
}
inline ::caffe::WindowDataParameter* LayerParameter::mutable_window_data_param() {
  set_has_window_data_param();
  if (window_data_param_ == NULL) window_data_param_ = new ::caffe::WindowDataParameter;
  return window_data_param_;
}
inline ::caffe::WindowDataParameter* LayerParameter::release_window_data_param() {
  clear_has_window_data_param();
  ::caffe::WindowDataParameter* temp = window_data_param_;
  window_data_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_window_data_param(::caffe::WindowDataParameter* window_data_param) {
  delete window_data_param_;
  window_data_param_ = window_data_param;
  if (window_data_param) {
    set_has_window_data_param();
  } else {
    clear_has_window_data_param();
  }
}

// optional .caffe.TransformationParameter transform_param = 36;
inline bool LayerParameter::has_transform_param() const {
  return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void LayerParameter::set_has_transform_param() {
  _has_bits_[1] |= 0x00000200u;
}
inline void LayerParameter::clear_has_transform_param() {
  _has_bits_[1] &= ~0x00000200u;
}
inline void LayerParameter::clear_transform_param() {
  if (transform_param_ != NULL) transform_param_->::caffe::TransformationParameter::Clear();
  clear_has_transform_param();
}
inline const ::caffe::TransformationParameter& LayerParameter::transform_param() const {
  return transform_param_ != NULL ? *transform_param_ : *default_instance_->transform_param_;
}
inline ::caffe::TransformationParameter* LayerParameter::mutable_transform_param() {
  set_has_transform_param();
  if (transform_param_ == NULL) transform_param_ = new ::caffe::TransformationParameter;
  return transform_param_;
}
inline ::caffe::TransformationParameter* LayerParameter::release_transform_param() {
  clear_has_transform_param();
  ::caffe::TransformationParameter* temp = transform_param_;
  transform_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_transform_param(::caffe::TransformationParameter* transform_param) {
  delete transform_param_;
  transform_param_ = transform_param;
  if (transform_param) {
    set_has_transform_param();
  } else {
    clear_has_transform_param();
  }
}

// optional .caffe.LossParameter loss_param = 42;
inline bool LayerParameter::has_loss_param() const {
  return (_has_bits_[1] & 0x00000400u) != 0;
}
inline void LayerParameter::set_has_loss_param() {
  _has_bits_[1] |= 0x00000400u;
}
inline void LayerParameter::clear_has_loss_param() {
  _has_bits_[1] &= ~0x00000400u;
}
inline void LayerParameter::clear_loss_param() {
  if (loss_param_ != NULL) loss_param_->::caffe::LossParameter::Clear();
  clear_has_loss_param();
}
inline const ::caffe::LossParameter& LayerParameter::loss_param() const {
  return loss_param_ != NULL ? *loss_param_ : *default_instance_->loss_param_;
}
inline ::caffe::LossParameter* LayerParameter::mutable_loss_param() {
  set_has_loss_param();
  if (loss_param_ == NULL) loss_param_ = new ::caffe::LossParameter;
  return loss_param_;
}
inline ::caffe::LossParameter* LayerParameter::release_loss_param() {
  clear_has_loss_param();
  ::caffe::LossParameter* temp = loss_param_;
  loss_param_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_loss_param(::caffe::LossParameter* loss_param) {
  delete loss_param_;
  loss_param_ = loss_param;
  if (loss_param) {
    set_has_loss_param();
  } else {
    clear_has_loss_param();
  }
}

// optional .caffe.V0LayerParameter layer = 1;
inline bool LayerParameter::has_layer() const {
  return (_has_bits_[1] & 0x00000800u) != 0;
}
inline void LayerParameter::set_has_layer() {
  _has_bits_[1] |= 0x00000800u;
}
inline void LayerParameter::clear_has_layer() {
  _has_bits_[1] &= ~0x00000800u;
}
inline void LayerParameter::clear_layer() {
  if (layer_ != NULL) layer_->::caffe::V0LayerParameter::Clear();
  clear_has_layer();
}
inline const ::caffe::V0LayerParameter& LayerParameter::layer() const {
  return layer_ != NULL ? *layer_ : *default_instance_->layer_;
}
inline ::caffe::V0LayerParameter* LayerParameter::mutable_layer() {
  set_has_layer();
  if (layer_ == NULL) layer_ = new ::caffe::V0LayerParameter;
  return layer_;
}
inline ::caffe::V0LayerParameter* LayerParameter::release_layer() {
  clear_has_layer();
  ::caffe::V0LayerParameter* temp = layer_;
  layer_ = NULL;
  return temp;
}
inline void LayerParameter::set_allocated_layer(::caffe::V0LayerParameter* layer) {
  delete layer_;
  layer_ = layer;
  if (layer) {
    set_has_layer();
  } else {
    clear_has_layer();
  }
}

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

// TransformationParameter

// optional float scale = 1 [default = 1];
inline bool TransformationParameter::has_scale() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransformationParameter::set_has_scale() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransformationParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TransformationParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float TransformationParameter::scale() const {
  return scale_;
}
inline void TransformationParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional bool mirror = 2 [default = false];
inline bool TransformationParameter::has_mirror() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TransformationParameter::set_has_mirror() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TransformationParameter::clear_has_mirror() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TransformationParameter::clear_mirror() {
  mirror_ = false;
  clear_has_mirror();
}
inline bool TransformationParameter::mirror() const {
  return mirror_;
}
inline void TransformationParameter::set_mirror(bool value) {
  set_has_mirror();
  mirror_ = value;
}

// optional uint32 crop_size = 3 [default = 0];
inline bool TransformationParameter::has_crop_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TransformationParameter::set_has_crop_size() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TransformationParameter::clear_has_crop_size() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TransformationParameter::clear_crop_size() {
  crop_size_ = 0u;
  clear_has_crop_size();
}
inline ::google::protobuf::uint32 TransformationParameter::crop_size() const {
  return crop_size_;
}
inline void TransformationParameter::set_crop_size(::google::protobuf::uint32 value) {
  set_has_crop_size();
  crop_size_ = value;
}

// optional string mean_file = 4;
inline bool TransformationParameter::has_mean_file() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TransformationParameter::set_has_mean_file() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TransformationParameter::clear_has_mean_file() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TransformationParameter::clear_mean_file() {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    mean_file_->clear();
  }
  clear_has_mean_file();
}
inline const ::std::string& TransformationParameter::mean_file() const {
  return *mean_file_;
}
inline void TransformationParameter::set_mean_file(const ::std::string& value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void TransformationParameter::set_mean_file(const char* value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void TransformationParameter::set_mean_file(const char* value, size_t size) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TransformationParameter::mutable_mean_file() {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  return mean_file_;
}
inline ::std::string* TransformationParameter::release_mean_file() {
  clear_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mean_file_;
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TransformationParameter::set_allocated_mean_file(::std::string* mean_file) {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    delete mean_file_;
  }
  if (mean_file) {
    set_has_mean_file();
    mean_file_ = mean_file;
  } else {
    clear_has_mean_file();
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated float mean_value = 5;
inline int TransformationParameter::mean_value_size() const {
  return mean_value_.size();
}
inline void TransformationParameter::clear_mean_value() {
  mean_value_.Clear();
}
inline float TransformationParameter::mean_value(int index) const {
  return mean_value_.Get(index);
}
inline void TransformationParameter::set_mean_value(int index, float value) {
  mean_value_.Set(index, value);
}
inline void TransformationParameter::add_mean_value(float value) {
  mean_value_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
TransformationParameter::mean_value() const {
  return mean_value_;
}
inline ::google::protobuf::RepeatedField< float >*
TransformationParameter::mutable_mean_value() {
  return &mean_value_;
}

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

// LossParameter

// optional int32 ignore_label = 1;
inline bool LossParameter::has_ignore_label() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LossParameter::set_has_ignore_label() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LossParameter::clear_has_ignore_label() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LossParameter::clear_ignore_label() {
  ignore_label_ = 0;
  clear_has_ignore_label();
}
inline ::google::protobuf::int32 LossParameter::ignore_label() const {
  return ignore_label_;
}
inline void LossParameter::set_ignore_label(::google::protobuf::int32 value) {
  set_has_ignore_label();
  ignore_label_ = value;
}

// optional bool normalize = 2 [default = true];
inline bool LossParameter::has_normalize() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LossParameter::set_has_normalize() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LossParameter::clear_has_normalize() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LossParameter::clear_normalize() {
  normalize_ = true;
  clear_has_normalize();
}
inline bool LossParameter::normalize() const {
  return normalize_;
}
inline void LossParameter::set_normalize(bool value) {
  set_has_normalize();
  normalize_ = value;
}

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

// AccuracyParameter

// optional uint32 top_k = 1 [default = 1];
inline bool AccuracyParameter::has_top_k() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AccuracyParameter::set_has_top_k() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AccuracyParameter::clear_has_top_k() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AccuracyParameter::clear_top_k() {
  top_k_ = 1u;
  clear_has_top_k();
}
inline ::google::protobuf::uint32 AccuracyParameter::top_k() const {
  return top_k_;
}
inline void AccuracyParameter::set_top_k(::google::protobuf::uint32 value) {
  set_has_top_k();
  top_k_ = value;
}

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

// ArgMaxParameter

// optional bool out_max_val = 1 [default = false];
inline bool ArgMaxParameter::has_out_max_val() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ArgMaxParameter::set_has_out_max_val() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ArgMaxParameter::clear_has_out_max_val() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ArgMaxParameter::clear_out_max_val() {
  out_max_val_ = false;
  clear_has_out_max_val();
}
inline bool ArgMaxParameter::out_max_val() const {
  return out_max_val_;
}
inline void ArgMaxParameter::set_out_max_val(bool value) {
  set_has_out_max_val();
  out_max_val_ = value;
}

// optional uint32 top_k = 2 [default = 1];
inline bool ArgMaxParameter::has_top_k() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ArgMaxParameter::set_has_top_k() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ArgMaxParameter::clear_has_top_k() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ArgMaxParameter::clear_top_k() {
  top_k_ = 1u;
  clear_has_top_k();
}
inline ::google::protobuf::uint32 ArgMaxParameter::top_k() const {
  return top_k_;
}
inline void ArgMaxParameter::set_top_k(::google::protobuf::uint32 value) {
  set_has_top_k();
  top_k_ = value;
}

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

// ConcatParameter

// optional uint32 concat_dim = 1 [default = 1];
inline bool ConcatParameter::has_concat_dim() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConcatParameter::set_has_concat_dim() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConcatParameter::clear_has_concat_dim() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConcatParameter::clear_concat_dim() {
  concat_dim_ = 1u;
  clear_has_concat_dim();
}
inline ::google::protobuf::uint32 ConcatParameter::concat_dim() const {
  return concat_dim_;
}
inline void ConcatParameter::set_concat_dim(::google::protobuf::uint32 value) {
  set_has_concat_dim();
  concat_dim_ = value;
}

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

// ContrastiveLossParameter

// optional float margin = 1 [default = 1];
inline bool ContrastiveLossParameter::has_margin() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ContrastiveLossParameter::set_has_margin() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ContrastiveLossParameter::clear_has_margin() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ContrastiveLossParameter::clear_margin() {
  margin_ = 1;
  clear_has_margin();
}
inline float ContrastiveLossParameter::margin() const {
  return margin_;
}
inline void ContrastiveLossParameter::set_margin(float value) {
  set_has_margin();
  margin_ = value;
}

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

// ConvolutionParameter

// optional uint32 num_output = 1;
inline bool ConvolutionParameter::has_num_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConvolutionParameter::set_has_num_output() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConvolutionParameter::clear_has_num_output() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConvolutionParameter::clear_num_output() {
  num_output_ = 0u;
  clear_has_num_output();
}
inline ::google::protobuf::uint32 ConvolutionParameter::num_output() const {
  return num_output_;
}
inline void ConvolutionParameter::set_num_output(::google::protobuf::uint32 value) {
  set_has_num_output();
  num_output_ = value;
}

// optional bool bias_term = 2 [default = true];
inline bool ConvolutionParameter::has_bias_term() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConvolutionParameter::set_has_bias_term() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ConvolutionParameter::clear_has_bias_term() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ConvolutionParameter::clear_bias_term() {
  bias_term_ = true;
  clear_has_bias_term();
}
inline bool ConvolutionParameter::bias_term() const {
  return bias_term_;
}
inline void ConvolutionParameter::set_bias_term(bool value) {
  set_has_bias_term();
  bias_term_ = value;
}

// optional uint32 pad = 3 [default = 0];
inline bool ConvolutionParameter::has_pad() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ConvolutionParameter::set_has_pad() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ConvolutionParameter::clear_has_pad() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ConvolutionParameter::clear_pad() {
  pad_ = 0u;
  clear_has_pad();
}
inline ::google::protobuf::uint32 ConvolutionParameter::pad() const {
  return pad_;
}
inline void ConvolutionParameter::set_pad(::google::protobuf::uint32 value) {
  set_has_pad();
  pad_ = value;
}

// optional uint32 pad_h = 9 [default = 0];
inline bool ConvolutionParameter::has_pad_h() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ConvolutionParameter::set_has_pad_h() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ConvolutionParameter::clear_has_pad_h() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ConvolutionParameter::clear_pad_h() {
  pad_h_ = 0u;
  clear_has_pad_h();
}
inline ::google::protobuf::uint32 ConvolutionParameter::pad_h() const {
  return pad_h_;
}
inline void ConvolutionParameter::set_pad_h(::google::protobuf::uint32 value) {
  set_has_pad_h();
  pad_h_ = value;
}

// optional uint32 pad_w = 10 [default = 0];
inline bool ConvolutionParameter::has_pad_w() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ConvolutionParameter::set_has_pad_w() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ConvolutionParameter::clear_has_pad_w() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ConvolutionParameter::clear_pad_w() {
  pad_w_ = 0u;
  clear_has_pad_w();
}
inline ::google::protobuf::uint32 ConvolutionParameter::pad_w() const {
  return pad_w_;
}
inline void ConvolutionParameter::set_pad_w(::google::protobuf::uint32 value) {
  set_has_pad_w();
  pad_w_ = value;
}

// optional uint32 kernel_size = 4;
inline bool ConvolutionParameter::has_kernel_size() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ConvolutionParameter::set_has_kernel_size() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ConvolutionParameter::clear_has_kernel_size() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ConvolutionParameter::clear_kernel_size() {
  kernel_size_ = 0u;
  clear_has_kernel_size();
}
inline ::google::protobuf::uint32 ConvolutionParameter::kernel_size() const {
  return kernel_size_;
}
inline void ConvolutionParameter::set_kernel_size(::google::protobuf::uint32 value) {
  set_has_kernel_size();
  kernel_size_ = value;
}

// optional uint32 kernel_h = 11;
inline bool ConvolutionParameter::has_kernel_h() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ConvolutionParameter::set_has_kernel_h() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ConvolutionParameter::clear_has_kernel_h() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ConvolutionParameter::clear_kernel_h() {
  kernel_h_ = 0u;
  clear_has_kernel_h();
}
inline ::google::protobuf::uint32 ConvolutionParameter::kernel_h() const {
  return kernel_h_;
}
inline void ConvolutionParameter::set_kernel_h(::google::protobuf::uint32 value) {
  set_has_kernel_h();
  kernel_h_ = value;
}

// optional uint32 kernel_w = 12;
inline bool ConvolutionParameter::has_kernel_w() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ConvolutionParameter::set_has_kernel_w() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ConvolutionParameter::clear_has_kernel_w() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ConvolutionParameter::clear_kernel_w() {
  kernel_w_ = 0u;
  clear_has_kernel_w();
}
inline ::google::protobuf::uint32 ConvolutionParameter::kernel_w() const {
  return kernel_w_;
}
inline void ConvolutionParameter::set_kernel_w(::google::protobuf::uint32 value) {
  set_has_kernel_w();
  kernel_w_ = value;
}

// optional uint32 group = 5 [default = 1];
inline bool ConvolutionParameter::has_group() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ConvolutionParameter::set_has_group() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ConvolutionParameter::clear_has_group() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ConvolutionParameter::clear_group() {
  group_ = 1u;
  clear_has_group();
}
inline ::google::protobuf::uint32 ConvolutionParameter::group() const {
  return group_;
}
inline void ConvolutionParameter::set_group(::google::protobuf::uint32 value) {
  set_has_group();
  group_ = value;
}

// optional uint32 stride = 6 [default = 1];
inline bool ConvolutionParameter::has_stride() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ConvolutionParameter::set_has_stride() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ConvolutionParameter::clear_has_stride() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ConvolutionParameter::clear_stride() {
  stride_ = 1u;
  clear_has_stride();
}
inline ::google::protobuf::uint32 ConvolutionParameter::stride() const {
  return stride_;
}
inline void ConvolutionParameter::set_stride(::google::protobuf::uint32 value) {
  set_has_stride();
  stride_ = value;
}

// optional uint32 stride_h = 13;
inline bool ConvolutionParameter::has_stride_h() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ConvolutionParameter::set_has_stride_h() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ConvolutionParameter::clear_has_stride_h() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ConvolutionParameter::clear_stride_h() {
  stride_h_ = 0u;
  clear_has_stride_h();
}
inline ::google::protobuf::uint32 ConvolutionParameter::stride_h() const {
  return stride_h_;
}
inline void ConvolutionParameter::set_stride_h(::google::protobuf::uint32 value) {
  set_has_stride_h();
  stride_h_ = value;
}

// optional uint32 stride_w = 14;
inline bool ConvolutionParameter::has_stride_w() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ConvolutionParameter::set_has_stride_w() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ConvolutionParameter::clear_has_stride_w() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ConvolutionParameter::clear_stride_w() {
  stride_w_ = 0u;
  clear_has_stride_w();
}
inline ::google::protobuf::uint32 ConvolutionParameter::stride_w() const {
  return stride_w_;
}
inline void ConvolutionParameter::set_stride_w(::google::protobuf::uint32 value) {
  set_has_stride_w();
  stride_w_ = value;
}

// optional .caffe.FillerParameter weight_filler = 7;
inline bool ConvolutionParameter::has_weight_filler() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ConvolutionParameter::set_has_weight_filler() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ConvolutionParameter::clear_has_weight_filler() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ConvolutionParameter::clear_weight_filler() {
  if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear();
  clear_has_weight_filler();
}
inline const ::caffe::FillerParameter& ConvolutionParameter::weight_filler() const {
  return weight_filler_ != NULL ? *weight_filler_ : *default_instance_->weight_filler_;
}
inline ::caffe::FillerParameter* ConvolutionParameter::mutable_weight_filler() {
  set_has_weight_filler();
  if (weight_filler_ == NULL) weight_filler_ = new ::caffe::FillerParameter;
  return weight_filler_;
}
inline ::caffe::FillerParameter* ConvolutionParameter::release_weight_filler() {
  clear_has_weight_filler();
  ::caffe::FillerParameter* temp = weight_filler_;
  weight_filler_ = NULL;
  return temp;
}
inline void ConvolutionParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
  delete weight_filler_;
  weight_filler_ = weight_filler;
  if (weight_filler) {
    set_has_weight_filler();
  } else {
    clear_has_weight_filler();
  }
}

// optional .caffe.FillerParameter bias_filler = 8;
inline bool ConvolutionParameter::has_bias_filler() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ConvolutionParameter::set_has_bias_filler() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ConvolutionParameter::clear_has_bias_filler() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ConvolutionParameter::clear_bias_filler() {
  if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear();
  clear_has_bias_filler();
}
inline const ::caffe::FillerParameter& ConvolutionParameter::bias_filler() const {
  return bias_filler_ != NULL ? *bias_filler_ : *default_instance_->bias_filler_;
}
inline ::caffe::FillerParameter* ConvolutionParameter::mutable_bias_filler() {
  set_has_bias_filler();
  if (bias_filler_ == NULL) bias_filler_ = new ::caffe::FillerParameter;
  return bias_filler_;
}
inline ::caffe::FillerParameter* ConvolutionParameter::release_bias_filler() {
  clear_has_bias_filler();
  ::caffe::FillerParameter* temp = bias_filler_;
  bias_filler_ = NULL;
  return temp;
}
inline void ConvolutionParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
  delete bias_filler_;
  bias_filler_ = bias_filler;
  if (bias_filler) {
    set_has_bias_filler();
  } else {
    clear_has_bias_filler();
  }
}

// optional .caffe.ConvolutionParameter.Engine engine = 15 [default = DEFAULT];
inline bool ConvolutionParameter::has_engine() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ConvolutionParameter::set_has_engine() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ConvolutionParameter::clear_has_engine() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ConvolutionParameter::clear_engine() {
  engine_ = 0;
  clear_has_engine();
}
inline ::caffe::ConvolutionParameter_Engine ConvolutionParameter::engine() const {
  return static_cast< ::caffe::ConvolutionParameter_Engine >(engine_);
}
inline void ConvolutionParameter::set_engine(::caffe::ConvolutionParameter_Engine value) {
  assert(::caffe::ConvolutionParameter_Engine_IsValid(value));
  set_has_engine();
  engine_ = value;
}

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

// MultiStageMeanfieldParameter

// optional .caffe.MultiStageMeanfieldParameter.Mode compatibility_mode = 1 [default = POTTS];
inline bool MultiStageMeanfieldParameter::has_compatibility_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_compatibility_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MultiStageMeanfieldParameter::clear_has_compatibility_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MultiStageMeanfieldParameter::clear_compatibility_mode() {
  compatibility_mode_ = 0;
  clear_has_compatibility_mode();
}
inline ::caffe::MultiStageMeanfieldParameter_Mode MultiStageMeanfieldParameter::compatibility_mode() const {
  return static_cast< ::caffe::MultiStageMeanfieldParameter_Mode >(compatibility_mode_);
}
inline void MultiStageMeanfieldParameter::set_compatibility_mode(::caffe::MultiStageMeanfieldParameter_Mode value) {
  assert(::caffe::MultiStageMeanfieldParameter_Mode_IsValid(value));
  set_has_compatibility_mode();
  compatibility_mode_ = value;
}

// optional float threshold = 2;
inline bool MultiStageMeanfieldParameter::has_threshold() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_threshold() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MultiStageMeanfieldParameter::clear_has_threshold() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MultiStageMeanfieldParameter::clear_threshold() {
  threshold_ = 0;
  clear_has_threshold();
}
inline float MultiStageMeanfieldParameter::threshold() const {
  return threshold_;
}
inline void MultiStageMeanfieldParameter::set_threshold(float value) {
  set_has_threshold();
  threshold_ = value;
}

// required float theta_alpha = 3 [default = 10];
inline bool MultiStageMeanfieldParameter::has_theta_alpha() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_theta_alpha() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MultiStageMeanfieldParameter::clear_has_theta_alpha() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MultiStageMeanfieldParameter::clear_theta_alpha() {
  theta_alpha_ = 10;
  clear_has_theta_alpha();
}
inline float MultiStageMeanfieldParameter::theta_alpha() const {
  return theta_alpha_;
}
inline void MultiStageMeanfieldParameter::set_theta_alpha(float value) {
  set_has_theta_alpha();
  theta_alpha_ = value;
}

// required float theta_beta = 4 [default = 10];
inline bool MultiStageMeanfieldParameter::has_theta_beta() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_theta_beta() {
  _has_bits_[0] |= 0x00000008u;
}
inline void MultiStageMeanfieldParameter::clear_has_theta_beta() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void MultiStageMeanfieldParameter::clear_theta_beta() {
  theta_beta_ = 10;
  clear_has_theta_beta();
}
inline float MultiStageMeanfieldParameter::theta_beta() const {
  return theta_beta_;
}
inline void MultiStageMeanfieldParameter::set_theta_beta(float value) {
  set_has_theta_beta();
  theta_beta_ = value;
}

// required float theta_gamma = 5 [default = 10];
inline bool MultiStageMeanfieldParameter::has_theta_gamma() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_theta_gamma() {
  _has_bits_[0] |= 0x00000010u;
}
inline void MultiStageMeanfieldParameter::clear_has_theta_gamma() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void MultiStageMeanfieldParameter::clear_theta_gamma() {
  theta_gamma_ = 10;
  clear_has_theta_gamma();
}
inline float MultiStageMeanfieldParameter::theta_gamma() const {
  return theta_gamma_;
}
inline void MultiStageMeanfieldParameter::set_theta_gamma(float value) {
  set_has_theta_gamma();
  theta_gamma_ = value;
}

// required uint32 num_iterations = 6 [default = 1];
inline bool MultiStageMeanfieldParameter::has_num_iterations() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_num_iterations() {
  _has_bits_[0] |= 0x00000020u;
}
inline void MultiStageMeanfieldParameter::clear_has_num_iterations() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void MultiStageMeanfieldParameter::clear_num_iterations() {
  num_iterations_ = 1u;
  clear_has_num_iterations();
}
inline ::google::protobuf::uint32 MultiStageMeanfieldParameter::num_iterations() const {
  return num_iterations_;
}
inline void MultiStageMeanfieldParameter::set_num_iterations(::google::protobuf::uint32 value) {
  set_has_num_iterations();
  num_iterations_ = value;
}

// optional float spatial_filter_weight = 7 [default = 1];
inline bool MultiStageMeanfieldParameter::has_spatial_filter_weight() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_spatial_filter_weight() {
  _has_bits_[0] |= 0x00000040u;
}
inline void MultiStageMeanfieldParameter::clear_has_spatial_filter_weight() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void MultiStageMeanfieldParameter::clear_spatial_filter_weight() {
  spatial_filter_weight_ = 1;
  clear_has_spatial_filter_weight();
}
inline float MultiStageMeanfieldParameter::spatial_filter_weight() const {
  return spatial_filter_weight_;
}
inline void MultiStageMeanfieldParameter::set_spatial_filter_weight(float value) {
  set_has_spatial_filter_weight();
  spatial_filter_weight_ = value;
}

// optional float bilateral_filter_weight = 8 [default = 1];
inline bool MultiStageMeanfieldParameter::has_bilateral_filter_weight() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_bilateral_filter_weight() {
  _has_bits_[0] |= 0x00000080u;
}
inline void MultiStageMeanfieldParameter::clear_has_bilateral_filter_weight() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void MultiStageMeanfieldParameter::clear_bilateral_filter_weight() {
  bilateral_filter_weight_ = 1;
  clear_has_bilateral_filter_weight();
}
inline float MultiStageMeanfieldParameter::bilateral_filter_weight() const {
  return bilateral_filter_weight_;
}
inline void MultiStageMeanfieldParameter::set_bilateral_filter_weight(float value) {
  set_has_bilateral_filter_weight();
  bilateral_filter_weight_ = value;
}

// optional float forced_spatial_filter_weight = 9;
inline bool MultiStageMeanfieldParameter::has_forced_spatial_filter_weight() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_forced_spatial_filter_weight() {
  _has_bits_[0] |= 0x00000100u;
}
inline void MultiStageMeanfieldParameter::clear_has_forced_spatial_filter_weight() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void MultiStageMeanfieldParameter::clear_forced_spatial_filter_weight() {
  forced_spatial_filter_weight_ = 0;
  clear_has_forced_spatial_filter_weight();
}
inline float MultiStageMeanfieldParameter::forced_spatial_filter_weight() const {
  return forced_spatial_filter_weight_;
}
inline void MultiStageMeanfieldParameter::set_forced_spatial_filter_weight(float value) {
  set_has_forced_spatial_filter_weight();
  forced_spatial_filter_weight_ = value;
}

// optional float forced_bilateral_filter_weight = 10;
inline bool MultiStageMeanfieldParameter::has_forced_bilateral_filter_weight() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void MultiStageMeanfieldParameter::set_has_forced_bilateral_filter_weight() {
  _has_bits_[0] |= 0x00000200u;
}
inline void MultiStageMeanfieldParameter::clear_has_forced_bilateral_filter_weight() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void MultiStageMeanfieldParameter::clear_forced_bilateral_filter_weight() {
  forced_bilateral_filter_weight_ = 0;
  clear_has_forced_bilateral_filter_weight();
}
inline float MultiStageMeanfieldParameter::forced_bilateral_filter_weight() const {
  return forced_bilateral_filter_weight_;
}
inline void MultiStageMeanfieldParameter::set_forced_bilateral_filter_weight(float value) {
  set_has_forced_bilateral_filter_weight();
  forced_bilateral_filter_weight_ = value;
}

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

// DataParameter

// optional string source = 1;
inline bool DataParameter::has_source() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DataParameter::set_has_source() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DataParameter::clear_has_source() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DataParameter::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& DataParameter::source() const {
  return *source_;
}
inline void DataParameter::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void DataParameter::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void DataParameter::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DataParameter::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* DataParameter::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DataParameter::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 batch_size = 4;
inline bool DataParameter::has_batch_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DataParameter::set_has_batch_size() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DataParameter::clear_has_batch_size() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DataParameter::clear_batch_size() {
  batch_size_ = 0u;
  clear_has_batch_size();
}
inline ::google::protobuf::uint32 DataParameter::batch_size() const {
  return batch_size_;
}
inline void DataParameter::set_batch_size(::google::protobuf::uint32 value) {
  set_has_batch_size();
  batch_size_ = value;
}

// optional uint32 rand_skip = 7 [default = 0];
inline bool DataParameter::has_rand_skip() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DataParameter::set_has_rand_skip() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DataParameter::clear_has_rand_skip() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DataParameter::clear_rand_skip() {
  rand_skip_ = 0u;
  clear_has_rand_skip();
}
inline ::google::protobuf::uint32 DataParameter::rand_skip() const {
  return rand_skip_;
}
inline void DataParameter::set_rand_skip(::google::protobuf::uint32 value) {
  set_has_rand_skip();
  rand_skip_ = value;
}

// optional .caffe.DataParameter.DB backend = 8 [default = LEVELDB];
inline bool DataParameter::has_backend() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DataParameter::set_has_backend() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DataParameter::clear_has_backend() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DataParameter::clear_backend() {
  backend_ = 0;
  clear_has_backend();
}
inline ::caffe::DataParameter_DB DataParameter::backend() const {
  return static_cast< ::caffe::DataParameter_DB >(backend_);
}
inline void DataParameter::set_backend(::caffe::DataParameter_DB value) {
  assert(::caffe::DataParameter_DB_IsValid(value));
  set_has_backend();
  backend_ = value;
}

// optional float scale = 2 [default = 1];
inline bool DataParameter::has_scale() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DataParameter::set_has_scale() {
  _has_bits_[0] |= 0x00000010u;
}
inline void DataParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void DataParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float DataParameter::scale() const {
  return scale_;
}
inline void DataParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional string mean_file = 3;
inline bool DataParameter::has_mean_file() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DataParameter::set_has_mean_file() {
  _has_bits_[0] |= 0x00000020u;
}
inline void DataParameter::clear_has_mean_file() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void DataParameter::clear_mean_file() {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    mean_file_->clear();
  }
  clear_has_mean_file();
}
inline const ::std::string& DataParameter::mean_file() const {
  return *mean_file_;
}
inline void DataParameter::set_mean_file(const ::std::string& value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void DataParameter::set_mean_file(const char* value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void DataParameter::set_mean_file(const char* value, size_t size) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DataParameter::mutable_mean_file() {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  return mean_file_;
}
inline ::std::string* DataParameter::release_mean_file() {
  clear_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mean_file_;
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DataParameter::set_allocated_mean_file(::std::string* mean_file) {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    delete mean_file_;
  }
  if (mean_file) {
    set_has_mean_file();
    mean_file_ = mean_file;
  } else {
    clear_has_mean_file();
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 crop_size = 5 [default = 0];
inline bool DataParameter::has_crop_size() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DataParameter::set_has_crop_size() {
  _has_bits_[0] |= 0x00000040u;
}
inline void DataParameter::clear_has_crop_size() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void DataParameter::clear_crop_size() {
  crop_size_ = 0u;
  clear_has_crop_size();
}
inline ::google::protobuf::uint32 DataParameter::crop_size() const {
  return crop_size_;
}
inline void DataParameter::set_crop_size(::google::protobuf::uint32 value) {
  set_has_crop_size();
  crop_size_ = value;
}

// optional bool mirror = 6 [default = false];
inline bool DataParameter::has_mirror() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void DataParameter::set_has_mirror() {
  _has_bits_[0] |= 0x00000080u;
}
inline void DataParameter::clear_has_mirror() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void DataParameter::clear_mirror() {
  mirror_ = false;
  clear_has_mirror();
}
inline bool DataParameter::mirror() const {
  return mirror_;
}
inline void DataParameter::set_mirror(bool value) {
  set_has_mirror();
  mirror_ = value;
}

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

// DropoutParameter

// optional float dropout_ratio = 1 [default = 0.5];
inline bool DropoutParameter::has_dropout_ratio() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DropoutParameter::set_has_dropout_ratio() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DropoutParameter::clear_has_dropout_ratio() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DropoutParameter::clear_dropout_ratio() {
  dropout_ratio_ = 0.5f;
  clear_has_dropout_ratio();
}
inline float DropoutParameter::dropout_ratio() const {
  return dropout_ratio_;
}
inline void DropoutParameter::set_dropout_ratio(float value) {
  set_has_dropout_ratio();
  dropout_ratio_ = value;
}

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

// DummyDataParameter

// repeated .caffe.FillerParameter data_filler = 1;
inline int DummyDataParameter::data_filler_size() const {
  return data_filler_.size();
}
inline void DummyDataParameter::clear_data_filler() {
  data_filler_.Clear();
}
inline const ::caffe::FillerParameter& DummyDataParameter::data_filler(int index) const {
  return data_filler_.Get(index);
}
inline ::caffe::FillerParameter* DummyDataParameter::mutable_data_filler(int index) {
  return data_filler_.Mutable(index);
}
inline ::caffe::FillerParameter* DummyDataParameter::add_data_filler() {
  return data_filler_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >&
DummyDataParameter::data_filler() const {
  return data_filler_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::FillerParameter >*
DummyDataParameter::mutable_data_filler() {
  return &data_filler_;
}

// repeated uint32 num = 2;
inline int DummyDataParameter::num_size() const {
  return num_.size();
}
inline void DummyDataParameter::clear_num() {
  num_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::num(int index) const {
  return num_.Get(index);
}
inline void DummyDataParameter::set_num(int index, ::google::protobuf::uint32 value) {
  num_.Set(index, value);
}
inline void DummyDataParameter::add_num(::google::protobuf::uint32 value) {
  num_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::num() const {
  return num_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_num() {
  return &num_;
}

// repeated uint32 channels = 3;
inline int DummyDataParameter::channels_size() const {
  return channels_.size();
}
inline void DummyDataParameter::clear_channels() {
  channels_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::channels(int index) const {
  return channels_.Get(index);
}
inline void DummyDataParameter::set_channels(int index, ::google::protobuf::uint32 value) {
  channels_.Set(index, value);
}
inline void DummyDataParameter::add_channels(::google::protobuf::uint32 value) {
  channels_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::channels() const {
  return channels_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_channels() {
  return &channels_;
}

// repeated uint32 height = 4;
inline int DummyDataParameter::height_size() const {
  return height_.size();
}
inline void DummyDataParameter::clear_height() {
  height_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::height(int index) const {
  return height_.Get(index);
}
inline void DummyDataParameter::set_height(int index, ::google::protobuf::uint32 value) {
  height_.Set(index, value);
}
inline void DummyDataParameter::add_height(::google::protobuf::uint32 value) {
  height_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::height() const {
  return height_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_height() {
  return &height_;
}

// repeated uint32 width = 5;
inline int DummyDataParameter::width_size() const {
  return width_.size();
}
inline void DummyDataParameter::clear_width() {
  width_.Clear();
}
inline ::google::protobuf::uint32 DummyDataParameter::width(int index) const {
  return width_.Get(index);
}
inline void DummyDataParameter::set_width(int index, ::google::protobuf::uint32 value) {
  width_.Set(index, value);
}
inline void DummyDataParameter::add_width(::google::protobuf::uint32 value) {
  width_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DummyDataParameter::width() const {
  return width_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DummyDataParameter::mutable_width() {
  return &width_;
}

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

// EltwiseParameter

// optional .caffe.EltwiseParameter.EltwiseOp operation = 1 [default = SUM];
inline bool EltwiseParameter::has_operation() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EltwiseParameter::set_has_operation() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EltwiseParameter::clear_has_operation() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EltwiseParameter::clear_operation() {
  operation_ = 1;
  clear_has_operation();
}
inline ::caffe::EltwiseParameter_EltwiseOp EltwiseParameter::operation() const {
  return static_cast< ::caffe::EltwiseParameter_EltwiseOp >(operation_);
}
inline void EltwiseParameter::set_operation(::caffe::EltwiseParameter_EltwiseOp value) {
  assert(::caffe::EltwiseParameter_EltwiseOp_IsValid(value));
  set_has_operation();
  operation_ = value;
}

// repeated float coeff = 2;
inline int EltwiseParameter::coeff_size() const {
  return coeff_.size();
}
inline void EltwiseParameter::clear_coeff() {
  coeff_.Clear();
}
inline float EltwiseParameter::coeff(int index) const {
  return coeff_.Get(index);
}
inline void EltwiseParameter::set_coeff(int index, float value) {
  coeff_.Set(index, value);
}
inline void EltwiseParameter::add_coeff(float value) {
  coeff_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
EltwiseParameter::coeff() const {
  return coeff_;
}
inline ::google::protobuf::RepeatedField< float >*
EltwiseParameter::mutable_coeff() {
  return &coeff_;
}

// optional bool stable_prod_grad = 3 [default = true];
inline bool EltwiseParameter::has_stable_prod_grad() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EltwiseParameter::set_has_stable_prod_grad() {
  _has_bits_[0] |= 0x00000004u;
}
inline void EltwiseParameter::clear_has_stable_prod_grad() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void EltwiseParameter::clear_stable_prod_grad() {
  stable_prod_grad_ = true;
  clear_has_stable_prod_grad();
}
inline bool EltwiseParameter::stable_prod_grad() const {
  return stable_prod_grad_;
}
inline void EltwiseParameter::set_stable_prod_grad(bool value) {
  set_has_stable_prod_grad();
  stable_prod_grad_ = value;
}

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

// ExpParameter

// optional float base = 1 [default = -1];
inline bool ExpParameter::has_base() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExpParameter::set_has_base() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExpParameter::clear_has_base() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExpParameter::clear_base() {
  base_ = -1;
  clear_has_base();
}
inline float ExpParameter::base() const {
  return base_;
}
inline void ExpParameter::set_base(float value) {
  set_has_base();
  base_ = value;
}

// optional float scale = 2 [default = 1];
inline bool ExpParameter::has_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExpParameter::set_has_scale() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ExpParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ExpParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float ExpParameter::scale() const {
  return scale_;
}
inline void ExpParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional float shift = 3 [default = 0];
inline bool ExpParameter::has_shift() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ExpParameter::set_has_shift() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ExpParameter::clear_has_shift() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ExpParameter::clear_shift() {
  shift_ = 0;
  clear_has_shift();
}
inline float ExpParameter::shift() const {
  return shift_;
}
inline void ExpParameter::set_shift(float value) {
  set_has_shift();
  shift_ = value;
}

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

// HDF5DataParameter

// optional string source = 1;
inline bool HDF5DataParameter::has_source() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HDF5DataParameter::set_has_source() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HDF5DataParameter::clear_has_source() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HDF5DataParameter::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& HDF5DataParameter::source() const {
  return *source_;
}
inline void HDF5DataParameter::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void HDF5DataParameter::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void HDF5DataParameter::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HDF5DataParameter::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* HDF5DataParameter::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HDF5DataParameter::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 batch_size = 2;
inline bool HDF5DataParameter::has_batch_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HDF5DataParameter::set_has_batch_size() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HDF5DataParameter::clear_has_batch_size() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HDF5DataParameter::clear_batch_size() {
  batch_size_ = 0u;
  clear_has_batch_size();
}
inline ::google::protobuf::uint32 HDF5DataParameter::batch_size() const {
  return batch_size_;
}
inline void HDF5DataParameter::set_batch_size(::google::protobuf::uint32 value) {
  set_has_batch_size();
  batch_size_ = value;
}

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

// HDF5OutputParameter

// optional string file_name = 1;
inline bool HDF5OutputParameter::has_file_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HDF5OutputParameter::set_has_file_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HDF5OutputParameter::clear_has_file_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HDF5OutputParameter::clear_file_name() {
  if (file_name_ != &::google::protobuf::internal::kEmptyString) {
    file_name_->clear();
  }
  clear_has_file_name();
}
inline const ::std::string& HDF5OutputParameter::file_name() const {
  return *file_name_;
}
inline void HDF5OutputParameter::set_file_name(const ::std::string& value) {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  file_name_->assign(value);
}
inline void HDF5OutputParameter::set_file_name(const char* value) {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  file_name_->assign(value);
}
inline void HDF5OutputParameter::set_file_name(const char* value, size_t size) {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  file_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HDF5OutputParameter::mutable_file_name() {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  return file_name_;
}
inline ::std::string* HDF5OutputParameter::release_file_name() {
  clear_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = file_name_;
    file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HDF5OutputParameter::set_allocated_file_name(::std::string* file_name) {
  if (file_name_ != &::google::protobuf::internal::kEmptyString) {
    delete file_name_;
  }
  if (file_name) {
    set_has_file_name();
    file_name_ = file_name;
  } else {
    clear_has_file_name();
    file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// HingeLossParameter

// optional .caffe.HingeLossParameter.Norm norm = 1 [default = L1];
inline bool HingeLossParameter::has_norm() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HingeLossParameter::set_has_norm() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HingeLossParameter::clear_has_norm() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HingeLossParameter::clear_norm() {
  norm_ = 1;
  clear_has_norm();
}
inline ::caffe::HingeLossParameter_Norm HingeLossParameter::norm() const {
  return static_cast< ::caffe::HingeLossParameter_Norm >(norm_);
}
inline void HingeLossParameter::set_norm(::caffe::HingeLossParameter_Norm value) {
  assert(::caffe::HingeLossParameter_Norm_IsValid(value));
  set_has_norm();
  norm_ = value;
}

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

// ImageDataParameter

// optional string source = 1;
inline bool ImageDataParameter::has_source() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ImageDataParameter::set_has_source() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ImageDataParameter::clear_has_source() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ImageDataParameter::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& ImageDataParameter::source() const {
  return *source_;
}
inline void ImageDataParameter::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void ImageDataParameter::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void ImageDataParameter::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ImageDataParameter::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* ImageDataParameter::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ImageDataParameter::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 batch_size = 4;
inline bool ImageDataParameter::has_batch_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ImageDataParameter::set_has_batch_size() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ImageDataParameter::clear_has_batch_size() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ImageDataParameter::clear_batch_size() {
  batch_size_ = 0u;
  clear_has_batch_size();
}
inline ::google::protobuf::uint32 ImageDataParameter::batch_size() const {
  return batch_size_;
}
inline void ImageDataParameter::set_batch_size(::google::protobuf::uint32 value) {
  set_has_batch_size();
  batch_size_ = value;
}

// optional uint32 rand_skip = 7 [default = 0];
inline bool ImageDataParameter::has_rand_skip() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ImageDataParameter::set_has_rand_skip() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ImageDataParameter::clear_has_rand_skip() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ImageDataParameter::clear_rand_skip() {
  rand_skip_ = 0u;
  clear_has_rand_skip();
}
inline ::google::protobuf::uint32 ImageDataParameter::rand_skip() const {
  return rand_skip_;
}
inline void ImageDataParameter::set_rand_skip(::google::protobuf::uint32 value) {
  set_has_rand_skip();
  rand_skip_ = value;
}

// optional bool shuffle = 8 [default = false];
inline bool ImageDataParameter::has_shuffle() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ImageDataParameter::set_has_shuffle() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ImageDataParameter::clear_has_shuffle() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ImageDataParameter::clear_shuffle() {
  shuffle_ = false;
  clear_has_shuffle();
}
inline bool ImageDataParameter::shuffle() const {
  return shuffle_;
}
inline void ImageDataParameter::set_shuffle(bool value) {
  set_has_shuffle();
  shuffle_ = value;
}

// optional uint32 new_height = 9 [default = 0];
inline bool ImageDataParameter::has_new_height() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ImageDataParameter::set_has_new_height() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ImageDataParameter::clear_has_new_height() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ImageDataParameter::clear_new_height() {
  new_height_ = 0u;
  clear_has_new_height();
}
inline ::google::protobuf::uint32 ImageDataParameter::new_height() const {
  return new_height_;
}
inline void ImageDataParameter::set_new_height(::google::protobuf::uint32 value) {
  set_has_new_height();
  new_height_ = value;
}

// optional uint32 new_width = 10 [default = 0];
inline bool ImageDataParameter::has_new_width() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ImageDataParameter::set_has_new_width() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ImageDataParameter::clear_has_new_width() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ImageDataParameter::clear_new_width() {
  new_width_ = 0u;
  clear_has_new_width();
}
inline ::google::protobuf::uint32 ImageDataParameter::new_width() const {
  return new_width_;
}
inline void ImageDataParameter::set_new_width(::google::protobuf::uint32 value) {
  set_has_new_width();
  new_width_ = value;
}

// optional bool is_color = 11 [default = true];
inline bool ImageDataParameter::has_is_color() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ImageDataParameter::set_has_is_color() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ImageDataParameter::clear_has_is_color() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ImageDataParameter::clear_is_color() {
  is_color_ = true;
  clear_has_is_color();
}
inline bool ImageDataParameter::is_color() const {
  return is_color_;
}
inline void ImageDataParameter::set_is_color(bool value) {
  set_has_is_color();
  is_color_ = value;
}

// optional float scale = 2 [default = 1];
inline bool ImageDataParameter::has_scale() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ImageDataParameter::set_has_scale() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ImageDataParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ImageDataParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float ImageDataParameter::scale() const {
  return scale_;
}
inline void ImageDataParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional string mean_file = 3;
inline bool ImageDataParameter::has_mean_file() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ImageDataParameter::set_has_mean_file() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ImageDataParameter::clear_has_mean_file() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ImageDataParameter::clear_mean_file() {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    mean_file_->clear();
  }
  clear_has_mean_file();
}
inline const ::std::string& ImageDataParameter::mean_file() const {
  return *mean_file_;
}
inline void ImageDataParameter::set_mean_file(const ::std::string& value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void ImageDataParameter::set_mean_file(const char* value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void ImageDataParameter::set_mean_file(const char* value, size_t size) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ImageDataParameter::mutable_mean_file() {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  return mean_file_;
}
inline ::std::string* ImageDataParameter::release_mean_file() {
  clear_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mean_file_;
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ImageDataParameter::set_allocated_mean_file(::std::string* mean_file) {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    delete mean_file_;
  }
  if (mean_file) {
    set_has_mean_file();
    mean_file_ = mean_file;
  } else {
    clear_has_mean_file();
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 crop_size = 5 [default = 0];
inline bool ImageDataParameter::has_crop_size() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ImageDataParameter::set_has_crop_size() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ImageDataParameter::clear_has_crop_size() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ImageDataParameter::clear_crop_size() {
  crop_size_ = 0u;
  clear_has_crop_size();
}
inline ::google::protobuf::uint32 ImageDataParameter::crop_size() const {
  return crop_size_;
}
inline void ImageDataParameter::set_crop_size(::google::protobuf::uint32 value) {
  set_has_crop_size();
  crop_size_ = value;
}

// optional bool mirror = 6 [default = false];
inline bool ImageDataParameter::has_mirror() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ImageDataParameter::set_has_mirror() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ImageDataParameter::clear_has_mirror() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ImageDataParameter::clear_mirror() {
  mirror_ = false;
  clear_has_mirror();
}
inline bool ImageDataParameter::mirror() const {
  return mirror_;
}
inline void ImageDataParameter::set_mirror(bool value) {
  set_has_mirror();
  mirror_ = value;
}

// optional string root_folder = 12 [default = ""];
inline bool ImageDataParameter::has_root_folder() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ImageDataParameter::set_has_root_folder() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ImageDataParameter::clear_has_root_folder() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ImageDataParameter::clear_root_folder() {
  if (root_folder_ != &::google::protobuf::internal::kEmptyString) {
    root_folder_->clear();
  }
  clear_has_root_folder();
}
inline const ::std::string& ImageDataParameter::root_folder() const {
  return *root_folder_;
}
inline void ImageDataParameter::set_root_folder(const ::std::string& value) {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  root_folder_->assign(value);
}
inline void ImageDataParameter::set_root_folder(const char* value) {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  root_folder_->assign(value);
}
inline void ImageDataParameter::set_root_folder(const char* value, size_t size) {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  root_folder_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ImageDataParameter::mutable_root_folder() {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  return root_folder_;
}
inline ::std::string* ImageDataParameter::release_root_folder() {
  clear_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = root_folder_;
    root_folder_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void ImageDataParameter::set_allocated_root_folder(::std::string* root_folder) {
  if (root_folder_ != &::google::protobuf::internal::kEmptyString) {
    delete root_folder_;
  }
  if (root_folder) {
    set_has_root_folder();
    root_folder_ = root_folder;
  } else {
    clear_has_root_folder();
    root_folder_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// InfogainLossParameter

// optional string source = 1;
inline bool InfogainLossParameter::has_source() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InfogainLossParameter::set_has_source() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InfogainLossParameter::clear_has_source() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InfogainLossParameter::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& InfogainLossParameter::source() const {
  return *source_;
}
inline void InfogainLossParameter::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void InfogainLossParameter::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void InfogainLossParameter::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* InfogainLossParameter::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* InfogainLossParameter::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void InfogainLossParameter::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// InnerProductParameter

// optional uint32 num_output = 1;
inline bool InnerProductParameter::has_num_output() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InnerProductParameter::set_has_num_output() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InnerProductParameter::clear_has_num_output() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InnerProductParameter::clear_num_output() {
  num_output_ = 0u;
  clear_has_num_output();
}
inline ::google::protobuf::uint32 InnerProductParameter::num_output() const {
  return num_output_;
}
inline void InnerProductParameter::set_num_output(::google::protobuf::uint32 value) {
  set_has_num_output();
  num_output_ = value;
}

// optional bool bias_term = 2 [default = true];
inline bool InnerProductParameter::has_bias_term() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void InnerProductParameter::set_has_bias_term() {
  _has_bits_[0] |= 0x00000002u;
}
inline void InnerProductParameter::clear_has_bias_term() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void InnerProductParameter::clear_bias_term() {
  bias_term_ = true;
  clear_has_bias_term();
}
inline bool InnerProductParameter::bias_term() const {
  return bias_term_;
}
inline void InnerProductParameter::set_bias_term(bool value) {
  set_has_bias_term();
  bias_term_ = value;
}

// optional .caffe.FillerParameter weight_filler = 3;
inline bool InnerProductParameter::has_weight_filler() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void InnerProductParameter::set_has_weight_filler() {
  _has_bits_[0] |= 0x00000004u;
}
inline void InnerProductParameter::clear_has_weight_filler() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void InnerProductParameter::clear_weight_filler() {
  if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear();
  clear_has_weight_filler();
}
inline const ::caffe::FillerParameter& InnerProductParameter::weight_filler() const {
  return weight_filler_ != NULL ? *weight_filler_ : *default_instance_->weight_filler_;
}
inline ::caffe::FillerParameter* InnerProductParameter::mutable_weight_filler() {
  set_has_weight_filler();
  if (weight_filler_ == NULL) weight_filler_ = new ::caffe::FillerParameter;
  return weight_filler_;
}
inline ::caffe::FillerParameter* InnerProductParameter::release_weight_filler() {
  clear_has_weight_filler();
  ::caffe::FillerParameter* temp = weight_filler_;
  weight_filler_ = NULL;
  return temp;
}
inline void InnerProductParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
  delete weight_filler_;
  weight_filler_ = weight_filler;
  if (weight_filler) {
    set_has_weight_filler();
  } else {
    clear_has_weight_filler();
  }
}

// optional .caffe.FillerParameter bias_filler = 4;
inline bool InnerProductParameter::has_bias_filler() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void InnerProductParameter::set_has_bias_filler() {
  _has_bits_[0] |= 0x00000008u;
}
inline void InnerProductParameter::clear_has_bias_filler() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void InnerProductParameter::clear_bias_filler() {
  if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear();
  clear_has_bias_filler();
}
inline const ::caffe::FillerParameter& InnerProductParameter::bias_filler() const {
  return bias_filler_ != NULL ? *bias_filler_ : *default_instance_->bias_filler_;
}
inline ::caffe::FillerParameter* InnerProductParameter::mutable_bias_filler() {
  set_has_bias_filler();
  if (bias_filler_ == NULL) bias_filler_ = new ::caffe::FillerParameter;
  return bias_filler_;
}
inline ::caffe::FillerParameter* InnerProductParameter::release_bias_filler() {
  clear_has_bias_filler();
  ::caffe::FillerParameter* temp = bias_filler_;
  bias_filler_ = NULL;
  return temp;
}
inline void InnerProductParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
  delete bias_filler_;
  bias_filler_ = bias_filler;
  if (bias_filler) {
    set_has_bias_filler();
  } else {
    clear_has_bias_filler();
  }
}

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

// LRNParameter

// optional uint32 local_size = 1 [default = 5];
inline bool LRNParameter::has_local_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LRNParameter::set_has_local_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LRNParameter::clear_has_local_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LRNParameter::clear_local_size() {
  local_size_ = 5u;
  clear_has_local_size();
}
inline ::google::protobuf::uint32 LRNParameter::local_size() const {
  return local_size_;
}
inline void LRNParameter::set_local_size(::google::protobuf::uint32 value) {
  set_has_local_size();
  local_size_ = value;
}

// optional float alpha = 2 [default = 1];
inline bool LRNParameter::has_alpha() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LRNParameter::set_has_alpha() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LRNParameter::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LRNParameter::clear_alpha() {
  alpha_ = 1;
  clear_has_alpha();
}
inline float LRNParameter::alpha() const {
  return alpha_;
}
inline void LRNParameter::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// optional float beta = 3 [default = 0.75];
inline bool LRNParameter::has_beta() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LRNParameter::set_has_beta() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LRNParameter::clear_has_beta() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LRNParameter::clear_beta() {
  beta_ = 0.75f;
  clear_has_beta();
}
inline float LRNParameter::beta() const {
  return beta_;
}
inline void LRNParameter::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

// optional .caffe.LRNParameter.NormRegion norm_region = 4 [default = ACROSS_CHANNELS];
inline bool LRNParameter::has_norm_region() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LRNParameter::set_has_norm_region() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LRNParameter::clear_has_norm_region() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LRNParameter::clear_norm_region() {
  norm_region_ = 0;
  clear_has_norm_region();
}
inline ::caffe::LRNParameter_NormRegion LRNParameter::norm_region() const {
  return static_cast< ::caffe::LRNParameter_NormRegion >(norm_region_);
}
inline void LRNParameter::set_norm_region(::caffe::LRNParameter_NormRegion value) {
  assert(::caffe::LRNParameter_NormRegion_IsValid(value));
  set_has_norm_region();
  norm_region_ = value;
}

// optional float k = 5 [default = 1];
inline bool LRNParameter::has_k() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LRNParameter::set_has_k() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LRNParameter::clear_has_k() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LRNParameter::clear_k() {
  k_ = 1;
  clear_has_k();
}
inline float LRNParameter::k() const {
  return k_;
}
inline void LRNParameter::set_k(float value) {
  set_has_k();
  k_ = value;
}

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

// MemoryDataParameter

// optional uint32 batch_size = 1;
inline bool MemoryDataParameter::has_batch_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MemoryDataParameter::set_has_batch_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MemoryDataParameter::clear_has_batch_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MemoryDataParameter::clear_batch_size() {
  batch_size_ = 0u;
  clear_has_batch_size();
}
inline ::google::protobuf::uint32 MemoryDataParameter::batch_size() const {
  return batch_size_;
}
inline void MemoryDataParameter::set_batch_size(::google::protobuf::uint32 value) {
  set_has_batch_size();
  batch_size_ = value;
}

// optional uint32 channels = 2;
inline bool MemoryDataParameter::has_channels() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MemoryDataParameter::set_has_channels() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MemoryDataParameter::clear_has_channels() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MemoryDataParameter::clear_channels() {
  channels_ = 0u;
  clear_has_channels();
}
inline ::google::protobuf::uint32 MemoryDataParameter::channels() const {
  return channels_;
}
inline void MemoryDataParameter::set_channels(::google::protobuf::uint32 value) {
  set_has_channels();
  channels_ = value;
}

// optional uint32 height = 3;
inline bool MemoryDataParameter::has_height() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MemoryDataParameter::set_has_height() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MemoryDataParameter::clear_has_height() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MemoryDataParameter::clear_height() {
  height_ = 0u;
  clear_has_height();
}
inline ::google::protobuf::uint32 MemoryDataParameter::height() const {
  return height_;
}
inline void MemoryDataParameter::set_height(::google::protobuf::uint32 value) {
  set_has_height();
  height_ = value;
}

// optional uint32 width = 4;
inline bool MemoryDataParameter::has_width() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MemoryDataParameter::set_has_width() {
  _has_bits_[0] |= 0x00000008u;
}
inline void MemoryDataParameter::clear_has_width() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void MemoryDataParameter::clear_width() {
  width_ = 0u;
  clear_has_width();
}
inline ::google::protobuf::uint32 MemoryDataParameter::width() const {
  return width_;
}
inline void MemoryDataParameter::set_width(::google::protobuf::uint32 value) {
  set_has_width();
  width_ = value;
}

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

// MVNParameter

// optional bool normalize_variance = 1 [default = true];
inline bool MVNParameter::has_normalize_variance() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MVNParameter::set_has_normalize_variance() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MVNParameter::clear_has_normalize_variance() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MVNParameter::clear_normalize_variance() {
  normalize_variance_ = true;
  clear_has_normalize_variance();
}
inline bool MVNParameter::normalize_variance() const {
  return normalize_variance_;
}
inline void MVNParameter::set_normalize_variance(bool value) {
  set_has_normalize_variance();
  normalize_variance_ = value;
}

// optional bool across_channels = 2 [default = false];
inline bool MVNParameter::has_across_channels() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MVNParameter::set_has_across_channels() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MVNParameter::clear_has_across_channels() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MVNParameter::clear_across_channels() {
  across_channels_ = false;
  clear_has_across_channels();
}
inline bool MVNParameter::across_channels() const {
  return across_channels_;
}
inline void MVNParameter::set_across_channels(bool value) {
  set_has_across_channels();
  across_channels_ = value;
}

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

// PoolingParameter

// optional .caffe.PoolingParameter.PoolMethod pool = 1 [default = MAX];
inline bool PoolingParameter::has_pool() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PoolingParameter::set_has_pool() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PoolingParameter::clear_has_pool() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PoolingParameter::clear_pool() {
  pool_ = 0;
  clear_has_pool();
}
inline ::caffe::PoolingParameter_PoolMethod PoolingParameter::pool() const {
  return static_cast< ::caffe::PoolingParameter_PoolMethod >(pool_);
}
inline void PoolingParameter::set_pool(::caffe::PoolingParameter_PoolMethod value) {
  assert(::caffe::PoolingParameter_PoolMethod_IsValid(value));
  set_has_pool();
  pool_ = value;
}

// optional uint32 pad = 4 [default = 0];
inline bool PoolingParameter::has_pad() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PoolingParameter::set_has_pad() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PoolingParameter::clear_has_pad() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PoolingParameter::clear_pad() {
  pad_ = 0u;
  clear_has_pad();
}
inline ::google::protobuf::uint32 PoolingParameter::pad() const {
  return pad_;
}
inline void PoolingParameter::set_pad(::google::protobuf::uint32 value) {
  set_has_pad();
  pad_ = value;
}

// optional uint32 pad_h = 9 [default = 0];
inline bool PoolingParameter::has_pad_h() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PoolingParameter::set_has_pad_h() {
  _has_bits_[0] |= 0x00000004u;
}
inline void PoolingParameter::clear_has_pad_h() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void PoolingParameter::clear_pad_h() {
  pad_h_ = 0u;
  clear_has_pad_h();
}
inline ::google::protobuf::uint32 PoolingParameter::pad_h() const {
  return pad_h_;
}
inline void PoolingParameter::set_pad_h(::google::protobuf::uint32 value) {
  set_has_pad_h();
  pad_h_ = value;
}

// optional uint32 pad_w = 10 [default = 0];
inline bool PoolingParameter::has_pad_w() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PoolingParameter::set_has_pad_w() {
  _has_bits_[0] |= 0x00000008u;
}
inline void PoolingParameter::clear_has_pad_w() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void PoolingParameter::clear_pad_w() {
  pad_w_ = 0u;
  clear_has_pad_w();
}
inline ::google::protobuf::uint32 PoolingParameter::pad_w() const {
  return pad_w_;
}
inline void PoolingParameter::set_pad_w(::google::protobuf::uint32 value) {
  set_has_pad_w();
  pad_w_ = value;
}

// optional uint32 kernel_size = 2;
inline bool PoolingParameter::has_kernel_size() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PoolingParameter::set_has_kernel_size() {
  _has_bits_[0] |= 0x00000010u;
}
inline void PoolingParameter::clear_has_kernel_size() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void PoolingParameter::clear_kernel_size() {
  kernel_size_ = 0u;
  clear_has_kernel_size();
}
inline ::google::protobuf::uint32 PoolingParameter::kernel_size() const {
  return kernel_size_;
}
inline void PoolingParameter::set_kernel_size(::google::protobuf::uint32 value) {
  set_has_kernel_size();
  kernel_size_ = value;
}

// optional uint32 kernel_h = 5;
inline bool PoolingParameter::has_kernel_h() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void PoolingParameter::set_has_kernel_h() {
  _has_bits_[0] |= 0x00000020u;
}
inline void PoolingParameter::clear_has_kernel_h() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void PoolingParameter::clear_kernel_h() {
  kernel_h_ = 0u;
  clear_has_kernel_h();
}
inline ::google::protobuf::uint32 PoolingParameter::kernel_h() const {
  return kernel_h_;
}
inline void PoolingParameter::set_kernel_h(::google::protobuf::uint32 value) {
  set_has_kernel_h();
  kernel_h_ = value;
}

// optional uint32 kernel_w = 6;
inline bool PoolingParameter::has_kernel_w() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void PoolingParameter::set_has_kernel_w() {
  _has_bits_[0] |= 0x00000040u;
}
inline void PoolingParameter::clear_has_kernel_w() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void PoolingParameter::clear_kernel_w() {
  kernel_w_ = 0u;
  clear_has_kernel_w();
}
inline ::google::protobuf::uint32 PoolingParameter::kernel_w() const {
  return kernel_w_;
}
inline void PoolingParameter::set_kernel_w(::google::protobuf::uint32 value) {
  set_has_kernel_w();
  kernel_w_ = value;
}

// optional uint32 stride = 3 [default = 1];
inline bool PoolingParameter::has_stride() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void PoolingParameter::set_has_stride() {
  _has_bits_[0] |= 0x00000080u;
}
inline void PoolingParameter::clear_has_stride() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void PoolingParameter::clear_stride() {
  stride_ = 1u;
  clear_has_stride();
}
inline ::google::protobuf::uint32 PoolingParameter::stride() const {
  return stride_;
}
inline void PoolingParameter::set_stride(::google::protobuf::uint32 value) {
  set_has_stride();
  stride_ = value;
}

// optional uint32 stride_h = 7;
inline bool PoolingParameter::has_stride_h() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void PoolingParameter::set_has_stride_h() {
  _has_bits_[0] |= 0x00000100u;
}
inline void PoolingParameter::clear_has_stride_h() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void PoolingParameter::clear_stride_h() {
  stride_h_ = 0u;
  clear_has_stride_h();
}
inline ::google::protobuf::uint32 PoolingParameter::stride_h() const {
  return stride_h_;
}
inline void PoolingParameter::set_stride_h(::google::protobuf::uint32 value) {
  set_has_stride_h();
  stride_h_ = value;
}

// optional uint32 stride_w = 8;
inline bool PoolingParameter::has_stride_w() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void PoolingParameter::set_has_stride_w() {
  _has_bits_[0] |= 0x00000200u;
}
inline void PoolingParameter::clear_has_stride_w() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void PoolingParameter::clear_stride_w() {
  stride_w_ = 0u;
  clear_has_stride_w();
}
inline ::google::protobuf::uint32 PoolingParameter::stride_w() const {
  return stride_w_;
}
inline void PoolingParameter::set_stride_w(::google::protobuf::uint32 value) {
  set_has_stride_w();
  stride_w_ = value;
}

// optional .caffe.PoolingParameter.Engine engine = 11 [default = DEFAULT];
inline bool PoolingParameter::has_engine() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void PoolingParameter::set_has_engine() {
  _has_bits_[0] |= 0x00000400u;
}
inline void PoolingParameter::clear_has_engine() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void PoolingParameter::clear_engine() {
  engine_ = 0;
  clear_has_engine();
}
inline ::caffe::PoolingParameter_Engine PoolingParameter::engine() const {
  return static_cast< ::caffe::PoolingParameter_Engine >(engine_);
}
inline void PoolingParameter::set_engine(::caffe::PoolingParameter_Engine value) {
  assert(::caffe::PoolingParameter_Engine_IsValid(value));
  set_has_engine();
  engine_ = value;
}

// optional bool global_pooling = 12 [default = false];
inline bool PoolingParameter::has_global_pooling() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void PoolingParameter::set_has_global_pooling() {
  _has_bits_[0] |= 0x00000800u;
}
inline void PoolingParameter::clear_has_global_pooling() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void PoolingParameter::clear_global_pooling() {
  global_pooling_ = false;
  clear_has_global_pooling();
}
inline bool PoolingParameter::global_pooling() const {
  return global_pooling_;
}
inline void PoolingParameter::set_global_pooling(bool value) {
  set_has_global_pooling();
  global_pooling_ = value;
}

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

// PowerParameter

// optional float power = 1 [default = 1];
inline bool PowerParameter::has_power() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PowerParameter::set_has_power() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PowerParameter::clear_has_power() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PowerParameter::clear_power() {
  power_ = 1;
  clear_has_power();
}
inline float PowerParameter::power() const {
  return power_;
}
inline void PowerParameter::set_power(float value) {
  set_has_power();
  power_ = value;
}

// optional float scale = 2 [default = 1];
inline bool PowerParameter::has_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PowerParameter::set_has_scale() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PowerParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PowerParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float PowerParameter::scale() const {
  return scale_;
}
inline void PowerParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional float shift = 3 [default = 0];
inline bool PowerParameter::has_shift() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PowerParameter::set_has_shift() {
  _has_bits_[0] |= 0x00000004u;
}
inline void PowerParameter::clear_has_shift() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void PowerParameter::clear_shift() {
  shift_ = 0;
  clear_has_shift();
}
inline float PowerParameter::shift() const {
  return shift_;
}
inline void PowerParameter::set_shift(float value) {
  set_has_shift();
  shift_ = value;
}

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

// ReLUParameter

// optional float negative_slope = 1 [default = 0];
inline bool ReLUParameter::has_negative_slope() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReLUParameter::set_has_negative_slope() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReLUParameter::clear_has_negative_slope() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReLUParameter::clear_negative_slope() {
  negative_slope_ = 0;
  clear_has_negative_slope();
}
inline float ReLUParameter::negative_slope() const {
  return negative_slope_;
}
inline void ReLUParameter::set_negative_slope(float value) {
  set_has_negative_slope();
  negative_slope_ = value;
}

// optional .caffe.ReLUParameter.Engine engine = 2 [default = DEFAULT];
inline bool ReLUParameter::has_engine() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReLUParameter::set_has_engine() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReLUParameter::clear_has_engine() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReLUParameter::clear_engine() {
  engine_ = 0;
  clear_has_engine();
}
inline ::caffe::ReLUParameter_Engine ReLUParameter::engine() const {
  return static_cast< ::caffe::ReLUParameter_Engine >(engine_);
}
inline void ReLUParameter::set_engine(::caffe::ReLUParameter_Engine value) {
  assert(::caffe::ReLUParameter_Engine_IsValid(value));
  set_has_engine();
  engine_ = value;
}

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

// SigmoidParameter

// optional .caffe.SigmoidParameter.Engine engine = 1 [default = DEFAULT];
inline bool SigmoidParameter::has_engine() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SigmoidParameter::set_has_engine() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SigmoidParameter::clear_has_engine() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SigmoidParameter::clear_engine() {
  engine_ = 0;
  clear_has_engine();
}
inline ::caffe::SigmoidParameter_Engine SigmoidParameter::engine() const {
  return static_cast< ::caffe::SigmoidParameter_Engine >(engine_);
}
inline void SigmoidParameter::set_engine(::caffe::SigmoidParameter_Engine value) {
  assert(::caffe::SigmoidParameter_Engine_IsValid(value));
  set_has_engine();
  engine_ = value;
}

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

// SliceParameter

// optional uint32 slice_dim = 1 [default = 1];
inline bool SliceParameter::has_slice_dim() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SliceParameter::set_has_slice_dim() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SliceParameter::clear_has_slice_dim() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SliceParameter::clear_slice_dim() {
  slice_dim_ = 1u;
  clear_has_slice_dim();
}
inline ::google::protobuf::uint32 SliceParameter::slice_dim() const {
  return slice_dim_;
}
inline void SliceParameter::set_slice_dim(::google::protobuf::uint32 value) {
  set_has_slice_dim();
  slice_dim_ = value;
}

// repeated uint32 slice_point = 2;
inline int SliceParameter::slice_point_size() const {
  return slice_point_.size();
}
inline void SliceParameter::clear_slice_point() {
  slice_point_.Clear();
}
inline ::google::protobuf::uint32 SliceParameter::slice_point(int index) const {
  return slice_point_.Get(index);
}
inline void SliceParameter::set_slice_point(int index, ::google::protobuf::uint32 value) {
  slice_point_.Set(index, value);
}
inline void SliceParameter::add_slice_point(::google::protobuf::uint32 value) {
  slice_point_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
SliceParameter::slice_point() const {
  return slice_point_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
SliceParameter::mutable_slice_point() {
  return &slice_point_;
}

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

// SoftmaxParameter

// optional .caffe.SoftmaxParameter.Engine engine = 1 [default = DEFAULT];
inline bool SoftmaxParameter::has_engine() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SoftmaxParameter::set_has_engine() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SoftmaxParameter::clear_has_engine() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SoftmaxParameter::clear_engine() {
  engine_ = 0;
  clear_has_engine();
}
inline ::caffe::SoftmaxParameter_Engine SoftmaxParameter::engine() const {
  return static_cast< ::caffe::SoftmaxParameter_Engine >(engine_);
}
inline void SoftmaxParameter::set_engine(::caffe::SoftmaxParameter_Engine value) {
  assert(::caffe::SoftmaxParameter_Engine_IsValid(value));
  set_has_engine();
  engine_ = value;
}

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

// TanHParameter

// optional .caffe.TanHParameter.Engine engine = 1 [default = DEFAULT];
inline bool TanHParameter::has_engine() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TanHParameter::set_has_engine() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TanHParameter::clear_has_engine() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TanHParameter::clear_engine() {
  engine_ = 0;
  clear_has_engine();
}
inline ::caffe::TanHParameter_Engine TanHParameter::engine() const {
  return static_cast< ::caffe::TanHParameter_Engine >(engine_);
}
inline void TanHParameter::set_engine(::caffe::TanHParameter_Engine value) {
  assert(::caffe::TanHParameter_Engine_IsValid(value));
  set_has_engine();
  engine_ = value;
}

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

// ThresholdParameter

// optional float threshold = 1 [default = 0];
inline bool ThresholdParameter::has_threshold() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ThresholdParameter::set_has_threshold() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ThresholdParameter::clear_has_threshold() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ThresholdParameter::clear_threshold() {
  threshold_ = 0;
  clear_has_threshold();
}
inline float ThresholdParameter::threshold() const {
  return threshold_;
}
inline void ThresholdParameter::set_threshold(float value) {
  set_has_threshold();
  threshold_ = value;
}

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

// WindowDataParameter

// optional string source = 1;
inline bool WindowDataParameter::has_source() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WindowDataParameter::set_has_source() {
  _has_bits_[0] |= 0x00000001u;
}
inline void WindowDataParameter::clear_has_source() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void WindowDataParameter::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& WindowDataParameter::source() const {
  return *source_;
}
inline void WindowDataParameter::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void WindowDataParameter::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void WindowDataParameter::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* WindowDataParameter::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* WindowDataParameter::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void WindowDataParameter::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional float scale = 2 [default = 1];
inline bool WindowDataParameter::has_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WindowDataParameter::set_has_scale() {
  _has_bits_[0] |= 0x00000002u;
}
inline void WindowDataParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void WindowDataParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float WindowDataParameter::scale() const {
  return scale_;
}
inline void WindowDataParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional string mean_file = 3;
inline bool WindowDataParameter::has_mean_file() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void WindowDataParameter::set_has_mean_file() {
  _has_bits_[0] |= 0x00000004u;
}
inline void WindowDataParameter::clear_has_mean_file() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void WindowDataParameter::clear_mean_file() {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    mean_file_->clear();
  }
  clear_has_mean_file();
}
inline const ::std::string& WindowDataParameter::mean_file() const {
  return *mean_file_;
}
inline void WindowDataParameter::set_mean_file(const ::std::string& value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void WindowDataParameter::set_mean_file(const char* value) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(value);
}
inline void WindowDataParameter::set_mean_file(const char* value, size_t size) {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  mean_file_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* WindowDataParameter::mutable_mean_file() {
  set_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    mean_file_ = new ::std::string;
  }
  return mean_file_;
}
inline ::std::string* WindowDataParameter::release_mean_file() {
  clear_has_mean_file();
  if (mean_file_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mean_file_;
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void WindowDataParameter::set_allocated_mean_file(::std::string* mean_file) {
  if (mean_file_ != &::google::protobuf::internal::kEmptyString) {
    delete mean_file_;
  }
  if (mean_file) {
    set_has_mean_file();
    mean_file_ = mean_file;
  } else {
    clear_has_mean_file();
    mean_file_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 batch_size = 4;
inline bool WindowDataParameter::has_batch_size() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void WindowDataParameter::set_has_batch_size() {
  _has_bits_[0] |= 0x00000008u;
}
inline void WindowDataParameter::clear_has_batch_size() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void WindowDataParameter::clear_batch_size() {
  batch_size_ = 0u;
  clear_has_batch_size();
}
inline ::google::protobuf::uint32 WindowDataParameter::batch_size() const {
  return batch_size_;
}
inline void WindowDataParameter::set_batch_size(::google::protobuf::uint32 value) {
  set_has_batch_size();
  batch_size_ = value;
}

// optional uint32 crop_size = 5 [default = 0];
inline bool WindowDataParameter::has_crop_size() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void WindowDataParameter::set_has_crop_size() {
  _has_bits_[0] |= 0x00000010u;
}
inline void WindowDataParameter::clear_has_crop_size() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void WindowDataParameter::clear_crop_size() {
  crop_size_ = 0u;
  clear_has_crop_size();
}
inline ::google::protobuf::uint32 WindowDataParameter::crop_size() const {
  return crop_size_;
}
inline void WindowDataParameter::set_crop_size(::google::protobuf::uint32 value) {
  set_has_crop_size();
  crop_size_ = value;
}

// optional bool mirror = 6 [default = false];
inline bool WindowDataParameter::has_mirror() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void WindowDataParameter::set_has_mirror() {
  _has_bits_[0] |= 0x00000020u;
}
inline void WindowDataParameter::clear_has_mirror() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void WindowDataParameter::clear_mirror() {
  mirror_ = false;
  clear_has_mirror();
}
inline bool WindowDataParameter::mirror() const {
  return mirror_;
}
inline void WindowDataParameter::set_mirror(bool value) {
  set_has_mirror();
  mirror_ = value;
}

// optional float fg_threshold = 7 [default = 0.5];
inline bool WindowDataParameter::has_fg_threshold() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void WindowDataParameter::set_has_fg_threshold() {
  _has_bits_[0] |= 0x00000040u;
}
inline void WindowDataParameter::clear_has_fg_threshold() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void WindowDataParameter::clear_fg_threshold() {
  fg_threshold_ = 0.5f;
  clear_has_fg_threshold();
}
inline float WindowDataParameter::fg_threshold() const {
  return fg_threshold_;
}
inline void WindowDataParameter::set_fg_threshold(float value) {
  set_has_fg_threshold();
  fg_threshold_ = value;
}

// optional float bg_threshold = 8 [default = 0.5];
inline bool WindowDataParameter::has_bg_threshold() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void WindowDataParameter::set_has_bg_threshold() {
  _has_bits_[0] |= 0x00000080u;
}
inline void WindowDataParameter::clear_has_bg_threshold() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void WindowDataParameter::clear_bg_threshold() {
  bg_threshold_ = 0.5f;
  clear_has_bg_threshold();
}
inline float WindowDataParameter::bg_threshold() const {
  return bg_threshold_;
}
inline void WindowDataParameter::set_bg_threshold(float value) {
  set_has_bg_threshold();
  bg_threshold_ = value;
}

// optional float fg_fraction = 9 [default = 0.25];
inline bool WindowDataParameter::has_fg_fraction() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void WindowDataParameter::set_has_fg_fraction() {
  _has_bits_[0] |= 0x00000100u;
}
inline void WindowDataParameter::clear_has_fg_fraction() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void WindowDataParameter::clear_fg_fraction() {
  fg_fraction_ = 0.25f;
  clear_has_fg_fraction();
}
inline float WindowDataParameter::fg_fraction() const {
  return fg_fraction_;
}
inline void WindowDataParameter::set_fg_fraction(float value) {
  set_has_fg_fraction();
  fg_fraction_ = value;
}

// optional uint32 context_pad = 10 [default = 0];
inline bool WindowDataParameter::has_context_pad() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void WindowDataParameter::set_has_context_pad() {
  _has_bits_[0] |= 0x00000200u;
}
inline void WindowDataParameter::clear_has_context_pad() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void WindowDataParameter::clear_context_pad() {
  context_pad_ = 0u;
  clear_has_context_pad();
}
inline ::google::protobuf::uint32 WindowDataParameter::context_pad() const {
  return context_pad_;
}
inline void WindowDataParameter::set_context_pad(::google::protobuf::uint32 value) {
  set_has_context_pad();
  context_pad_ = value;
}

// optional string crop_mode = 11 [default = "warp"];
inline bool WindowDataParameter::has_crop_mode() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void WindowDataParameter::set_has_crop_mode() {
  _has_bits_[0] |= 0x00000400u;
}
inline void WindowDataParameter::clear_has_crop_mode() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void WindowDataParameter::clear_crop_mode() {
  if (crop_mode_ != _default_crop_mode_) {
    crop_mode_->assign(*_default_crop_mode_);
  }
  clear_has_crop_mode();
}
inline const ::std::string& WindowDataParameter::crop_mode() const {
  return *crop_mode_;
}
inline void WindowDataParameter::set_crop_mode(const ::std::string& value) {
  set_has_crop_mode();
  if (crop_mode_ == _default_crop_mode_) {
    crop_mode_ = new ::std::string;
  }
  crop_mode_->assign(value);
}
inline void WindowDataParameter::set_crop_mode(const char* value) {
  set_has_crop_mode();
  if (crop_mode_ == _default_crop_mode_) {
    crop_mode_ = new ::std::string;
  }
  crop_mode_->assign(value);
}
inline void WindowDataParameter::set_crop_mode(const char* value, size_t size) {
  set_has_crop_mode();
  if (crop_mode_ == _default_crop_mode_) {
    crop_mode_ = new ::std::string;
  }
  crop_mode_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* WindowDataParameter::mutable_crop_mode() {
  set_has_crop_mode();
  if (crop_mode_ == _default_crop_mode_) {
    crop_mode_ = new ::std::string(*_default_crop_mode_);
  }
  return crop_mode_;
}
inline ::std::string* WindowDataParameter::release_crop_mode() {
  clear_has_crop_mode();
  if (crop_mode_ == _default_crop_mode_) {
    return NULL;
  } else {
    ::std::string* temp = crop_mode_;
    crop_mode_ = const_cast< ::std::string*>(_default_crop_mode_);
    return temp;
  }
}
inline void WindowDataParameter::set_allocated_crop_mode(::std::string* crop_mode) {
  if (crop_mode_ != _default_crop_mode_) {
    delete crop_mode_;
  }
  if (crop_mode) {
    set_has_crop_mode();
    crop_mode_ = crop_mode;
  } else {
    clear_has_crop_mode();
    crop_mode_ = const_cast< ::std::string*>(_default_crop_mode_);
  }
}

// optional bool cache_images = 12 [default = false];
inline bool WindowDataParameter::has_cache_images() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void WindowDataParameter::set_has_cache_images() {
  _has_bits_[0] |= 0x00000800u;
}
inline void WindowDataParameter::clear_has_cache_images() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void WindowDataParameter::clear_cache_images() {
  cache_images_ = false;
  clear_has_cache_images();
}
inline bool WindowDataParameter::cache_images() const {
  return cache_images_;
}
inline void WindowDataParameter::set_cache_images(bool value) {
  set_has_cache_images();
  cache_images_ = value;
}

// optional string root_folder = 13 [default = ""];
inline bool WindowDataParameter::has_root_folder() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void WindowDataParameter::set_has_root_folder() {
  _has_bits_[0] |= 0x00001000u;
}
inline void WindowDataParameter::clear_has_root_folder() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void WindowDataParameter::clear_root_folder() {
  if (root_folder_ != &::google::protobuf::internal::kEmptyString) {
    root_folder_->clear();
  }
  clear_has_root_folder();
}
inline const ::std::string& WindowDataParameter::root_folder() const {
  return *root_folder_;
}
inline void WindowDataParameter::set_root_folder(const ::std::string& value) {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  root_folder_->assign(value);
}
inline void WindowDataParameter::set_root_folder(const char* value) {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  root_folder_->assign(value);
}
inline void WindowDataParameter::set_root_folder(const char* value, size_t size) {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  root_folder_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* WindowDataParameter::mutable_root_folder() {
  set_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    root_folder_ = new ::std::string;
  }
  return root_folder_;
}
inline ::std::string* WindowDataParameter::release_root_folder() {
  clear_has_root_folder();
  if (root_folder_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = root_folder_;
    root_folder_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void WindowDataParameter::set_allocated_root_folder(::std::string* root_folder) {
  if (root_folder_ != &::google::protobuf::internal::kEmptyString) {
    delete root_folder_;
  }
  if (root_folder) {
    set_has_root_folder();
    root_folder_ = root_folder;
  } else {
    clear_has_root_folder();
    root_folder_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// V0LayerParameter

// optional string name = 1;
inline bool V0LayerParameter::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void V0LayerParameter::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void V0LayerParameter::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void V0LayerParameter::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& V0LayerParameter::name() const {
  return *name_;
}
inline void V0LayerParameter::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void V0LayerParameter::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void V0LayerParameter::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* V0LayerParameter::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* V0LayerParameter::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void V0LayerParameter::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string type = 2;
inline bool V0LayerParameter::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void V0LayerParameter::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void V0LayerParameter::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void V0LayerParameter::clear_type() {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    type_->clear();
  }
  clear_has_type();
}
inline const ::std::string& V0LayerParameter::type() const {
  return *type_;
}
inline void V0LayerParameter::set_type(const ::std::string& value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void V0LayerParameter::set_type(const char* value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(value);
}
inline void V0LayerParameter::set_type(const char* value, size_t size) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* V0LayerParameter::mutable_type() {
  set_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    type_ = new ::std::string;
  }
  return type_;
}
inline ::std::string* V0LayerParameter::release_type() {
  clear_has_type();
  if (type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = type_;
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void V0LayerParameter::set_allocated_type(::std::string* type) {
  if (type_ != &::google::protobuf::internal::kEmptyString) {
    delete type_;
  }
  if (type) {
    set_has_type();
    type_ = type;
  } else {
    clear_has_type();
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 num_output = 3;
inline bool V0LayerParameter::has_num_output() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void V0LayerParameter::set_has_num_output() {
  _has_bits_[0] |= 0x00000004u;
}
inline void V0LayerParameter::clear_has_num_output() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void V0LayerParameter::clear_num_output() {
  num_output_ = 0u;
  clear_has_num_output();
}
inline ::google::protobuf::uint32 V0LayerParameter::num_output() const {
  return num_output_;
}
inline void V0LayerParameter::set_num_output(::google::protobuf::uint32 value) {
  set_has_num_output();
  num_output_ = value;
}

// optional bool biasterm = 4 [default = true];
inline bool V0LayerParameter::has_biasterm() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void V0LayerParameter::set_has_biasterm() {
  _has_bits_[0] |= 0x00000008u;
}
inline void V0LayerParameter::clear_has_biasterm() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void V0LayerParameter::clear_biasterm() {
  biasterm_ = true;
  clear_has_biasterm();
}
inline bool V0LayerParameter::biasterm() const {
  return biasterm_;
}
inline void V0LayerParameter::set_biasterm(bool value) {
  set_has_biasterm();
  biasterm_ = value;
}

// optional .caffe.FillerParameter weight_filler = 5;
inline bool V0LayerParameter::has_weight_filler() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void V0LayerParameter::set_has_weight_filler() {
  _has_bits_[0] |= 0x00000010u;
}
inline void V0LayerParameter::clear_has_weight_filler() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void V0LayerParameter::clear_weight_filler() {
  if (weight_filler_ != NULL) weight_filler_->::caffe::FillerParameter::Clear();
  clear_has_weight_filler();
}
inline const ::caffe::FillerParameter& V0LayerParameter::weight_filler() const {
  return weight_filler_ != NULL ? *weight_filler_ : *default_instance_->weight_filler_;
}
inline ::caffe::FillerParameter* V0LayerParameter::mutable_weight_filler() {
  set_has_weight_filler();
  if (weight_filler_ == NULL) weight_filler_ = new ::caffe::FillerParameter;
  return weight_filler_;
}
inline ::caffe::FillerParameter* V0LayerParameter::release_weight_filler() {
  clear_has_weight_filler();
  ::caffe::FillerParameter* temp = weight_filler_;
  weight_filler_ = NULL;
  return temp;
}
inline void V0LayerParameter::set_allocated_weight_filler(::caffe::FillerParameter* weight_filler) {
  delete weight_filler_;
  weight_filler_ = weight_filler;
  if (weight_filler) {
    set_has_weight_filler();
  } else {
    clear_has_weight_filler();
  }
}

// optional .caffe.FillerParameter bias_filler = 6;
inline bool V0LayerParameter::has_bias_filler() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void V0LayerParameter::set_has_bias_filler() {
  _has_bits_[0] |= 0x00000020u;
}
inline void V0LayerParameter::clear_has_bias_filler() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void V0LayerParameter::clear_bias_filler() {
  if (bias_filler_ != NULL) bias_filler_->::caffe::FillerParameter::Clear();
  clear_has_bias_filler();
}
inline const ::caffe::FillerParameter& V0LayerParameter::bias_filler() const {
  return bias_filler_ != NULL ? *bias_filler_ : *default_instance_->bias_filler_;
}
inline ::caffe::FillerParameter* V0LayerParameter::mutable_bias_filler() {
  set_has_bias_filler();
  if (bias_filler_ == NULL) bias_filler_ = new ::caffe::FillerParameter;
  return bias_filler_;
}
inline ::caffe::FillerParameter* V0LayerParameter::release_bias_filler() {
  clear_has_bias_filler();
  ::caffe::FillerParameter* temp = bias_filler_;
  bias_filler_ = NULL;
  return temp;
}
inline void V0LayerParameter::set_allocated_bias_filler(::caffe::FillerParameter* bias_filler) {
  delete bias_filler_;
  bias_filler_ = bias_filler;
  if (bias_filler) {
    set_has_bias_filler();
  } else {
    clear_has_bias_filler();
  }
}

// optional uint32 pad = 7 [default = 0];
inline bool V0LayerParameter::has_pad() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void V0LayerParameter::set_has_pad() {
  _has_bits_[0] |= 0x00000040u;
}
inline void V0LayerParameter::clear_has_pad() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void V0LayerParameter::clear_pad() {
  pad_ = 0u;
  clear_has_pad();
}
inline ::google::protobuf::uint32 V0LayerParameter::pad() const {
  return pad_;
}
inline void V0LayerParameter::set_pad(::google::protobuf::uint32 value) {
  set_has_pad();
  pad_ = value;
}

// optional uint32 kernelsize = 8;
inline bool V0LayerParameter::has_kernelsize() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void V0LayerParameter::set_has_kernelsize() {
  _has_bits_[0] |= 0x00000080u;
}
inline void V0LayerParameter::clear_has_kernelsize() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void V0LayerParameter::clear_kernelsize() {
  kernelsize_ = 0u;
  clear_has_kernelsize();
}
inline ::google::protobuf::uint32 V0LayerParameter::kernelsize() const {
  return kernelsize_;
}
inline void V0LayerParameter::set_kernelsize(::google::protobuf::uint32 value) {
  set_has_kernelsize();
  kernelsize_ = value;
}

// optional uint32 group = 9 [default = 1];
inline bool V0LayerParameter::has_group() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void V0LayerParameter::set_has_group() {
  _has_bits_[0] |= 0x00000100u;
}
inline void V0LayerParameter::clear_has_group() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void V0LayerParameter::clear_group() {
  group_ = 1u;
  clear_has_group();
}
inline ::google::protobuf::uint32 V0LayerParameter::group() const {
  return group_;
}
inline void V0LayerParameter::set_group(::google::protobuf::uint32 value) {
  set_has_group();
  group_ = value;
}

// optional uint32 stride = 10 [default = 1];
inline bool V0LayerParameter::has_stride() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void V0LayerParameter::set_has_stride() {
  _has_bits_[0] |= 0x00000200u;
}
inline void V0LayerParameter::clear_has_stride() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void V0LayerParameter::clear_stride() {
  stride_ = 1u;
  clear_has_stride();
}
inline ::google::protobuf::uint32 V0LayerParameter::stride() const {
  return stride_;
}
inline void V0LayerParameter::set_stride(::google::protobuf::uint32 value) {
  set_has_stride();
  stride_ = value;
}

// optional .caffe.V0LayerParameter.PoolMethod pool = 11 [default = MAX];
inline bool V0LayerParameter::has_pool() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void V0LayerParameter::set_has_pool() {
  _has_bits_[0] |= 0x00000400u;
}
inline void V0LayerParameter::clear_has_pool() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void V0LayerParameter::clear_pool() {
  pool_ = 0;
  clear_has_pool();
}
inline ::caffe::V0LayerParameter_PoolMethod V0LayerParameter::pool() const {
  return static_cast< ::caffe::V0LayerParameter_PoolMethod >(pool_);
}
inline void V0LayerParameter::set_pool(::caffe::V0LayerParameter_PoolMethod value) {
  assert(::caffe::V0LayerParameter_PoolMethod_IsValid(value));
  set_has_pool();
  pool_ = value;
}

// optional float dropout_ratio = 12 [default = 0.5];
inline bool V0LayerParameter::has_dropout_ratio() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void V0LayerParameter::set_has_dropout_ratio() {
  _has_bits_[0] |= 0x00000800u;
}
inline void V0LayerParameter::clear_has_dropout_ratio() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void V0LayerParameter::clear_dropout_ratio() {
  dropout_ratio_ = 0.5f;
  clear_has_dropout_ratio();
}
inline float V0LayerParameter::dropout_ratio() const {
  return dropout_ratio_;
}
inline void V0LayerParameter::set_dropout_ratio(float value) {
  set_has_dropout_ratio();
  dropout_ratio_ = value;
}

// optional uint32 local_size = 13 [default = 5];
inline bool V0LayerParameter::has_local_size() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void V0LayerParameter::set_has_local_size() {
  _has_bits_[0] |= 0x00001000u;
}
inline void V0LayerParameter::clear_has_local_size() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void V0LayerParameter::clear_local_size() {
  local_size_ = 5u;
  clear_has_local_size();
}
inline ::google::protobuf::uint32 V0LayerParameter::local_size() const {
  return local_size_;
}
inline void V0LayerParameter::set_local_size(::google::protobuf::uint32 value) {
  set_has_local_size();
  local_size_ = value;
}

// optional float alpha = 14 [default = 1];
inline bool V0LayerParameter::has_alpha() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void V0LayerParameter::set_has_alpha() {
  _has_bits_[0] |= 0x00002000u;
}
inline void V0LayerParameter::clear_has_alpha() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void V0LayerParameter::clear_alpha() {
  alpha_ = 1;
  clear_has_alpha();
}
inline float V0LayerParameter::alpha() const {
  return alpha_;
}
inline void V0LayerParameter::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// optional float beta = 15 [default = 0.75];
inline bool V0LayerParameter::has_beta() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void V0LayerParameter::set_has_beta() {
  _has_bits_[0] |= 0x00004000u;
}
inline void V0LayerParameter::clear_has_beta() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void V0LayerParameter::clear_beta() {
  beta_ = 0.75f;
  clear_has_beta();
}
inline float V0LayerParameter::beta() const {
  return beta_;
}
inline void V0LayerParameter::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

// optional float k = 22 [default = 1];
inline bool V0LayerParameter::has_k() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void V0LayerParameter::set_has_k() {
  _has_bits_[0] |= 0x00008000u;
}
inline void V0LayerParameter::clear_has_k() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void V0LayerParameter::clear_k() {
  k_ = 1;
  clear_has_k();
}
inline float V0LayerParameter::k() const {
  return k_;
}
inline void V0LayerParameter::set_k(float value) {
  set_has_k();
  k_ = value;
}

// optional string source = 16;
inline bool V0LayerParameter::has_source() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void V0LayerParameter::set_has_source() {
  _has_bits_[0] |= 0x00010000u;
}
inline void V0LayerParameter::clear_has_source() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void V0LayerParameter::clear_source() {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    source_->clear();
  }
  clear_has_source();
}
inline const ::std::string& V0LayerParameter::source() const {
  return *source_;
}
inline void V0LayerParameter::set_source(const ::std::string& value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void V0LayerParameter::set_source(const char* value) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(value);
}
inline void V0LayerParameter::set_source(const char* value, size_t size) {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* V0LayerParameter::mutable_source() {
  set_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    source_ = new ::std::string;
  }
  return source_;
}
inline ::std::string* V0LayerParameter::release_source() {
  clear_has_source();
  if (source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_;
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void V0LayerParameter::set_allocated_source(::std::string* source) {
  if (source_ != &::google::protobuf::internal::kEmptyString) {
    delete source_;
  }
  if (source) {
    set_has_source();
    source_ = source;
  } else {
    clear_has_source();
    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional float scale = 17 [default = 1];
inline bool V0LayerParameter::has_scale() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void V0LayerParameter::set_has_scale() {
  _has_bits_[0] |= 0x00020000u;
}
inline void V0LayerParameter::clear_has_scale() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void V0LayerParameter::clear_scale() {
  scale_ = 1;
  clear_has_scale();
}
inline float V0LayerParameter::scale() const {
  return scale_;
}
inline void V0LayerParameter::set_scale(float value) {
  set_has_scale();
  scale_ = value;
}

// optional string meanfile = 18;
inline bool V0LayerParameter::has_meanfile() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void V0LayerParameter::set_has_meanfile() {
  _has_bits_[0] |= 0x00040000u;
}
inline void V0LayerParameter::clear_has_meanfile() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void V0LayerParameter::clear_meanfile() {
  if (meanfile_ != &::google::protobuf::internal::kEmptyString) {
    meanfile_->clear();
  }
  clear_has_meanfile();
}
inline const ::std::string& V0LayerParameter::meanfile() const {
  return *meanfile_;
}
inline void V0LayerParameter::set_meanfile(const ::std::string& value) {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  meanfile_->assign(value);
}
inline void V0LayerParameter::set_meanfile(const char* value) {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  meanfile_->assign(value);
}
inline void V0LayerParameter::set_meanfile(const char* value, size_t size) {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  meanfile_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* V0LayerParameter::mutable_meanfile() {
  set_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    meanfile_ = new ::std::string;
  }
  return meanfile_;
}
inline ::std::string* V0LayerParameter::release_meanfile() {
  clear_has_meanfile();
  if (meanfile_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = meanfile_;
    meanfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void V0LayerParameter::set_allocated_meanfile(::std::string* meanfile) {
  if (meanfile_ != &::google::protobuf::internal::kEmptyString) {
    delete meanfile_;
  }
  if (meanfile) {
    set_has_meanfile();
    meanfile_ = meanfile;
  } else {
    clear_has_meanfile();
    meanfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 batchsize = 19;
inline bool V0LayerParameter::has_batchsize() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void V0LayerParameter::set_has_batchsize() {
  _has_bits_[0] |= 0x00080000u;
}
inline void V0LayerParameter::clear_has_batchsize() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void V0LayerParameter::clear_batchsize() {
  batchsize_ = 0u;
  clear_has_batchsize();
}
inline ::google::protobuf::uint32 V0LayerParameter::batchsize() const {
  return batchsize_;
}
inline void V0LayerParameter::set_batchsize(::google::protobuf::uint32 value) {
  set_has_batchsize();
  batchsize_ = value;
}

// optional uint32 cropsize = 20 [default = 0];
inline bool V0LayerParameter::has_cropsize() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void V0LayerParameter::set_has_cropsize() {
  _has_bits_[0] |= 0x00100000u;
}
inline void V0LayerParameter::clear_has_cropsize() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void V0LayerParameter::clear_cropsize() {
  cropsize_ = 0u;
  clear_has_cropsize();
}
inline ::google::protobuf::uint32 V0LayerParameter::cropsize() const {
  return cropsize_;
}
inline void V0LayerParameter::set_cropsize(::google::protobuf::uint32 value) {
  set_has_cropsize();
  cropsize_ = value;
}

// optional bool mirror = 21 [default = false];
inline bool V0LayerParameter::has_mirror() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void V0LayerParameter::set_has_mirror() {
  _has_bits_[0] |= 0x00200000u;
}
inline void V0LayerParameter::clear_has_mirror() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void V0LayerParameter::clear_mirror() {
  mirror_ = false;
  clear_has_mirror();
}
inline bool V0LayerParameter::mirror() const {
  return mirror_;
}
inline void V0LayerParameter::set_mirror(bool value) {
  set_has_mirror();
  mirror_ = value;
}

// repeated .caffe.BlobProto blobs = 50;
inline int V0LayerParameter::blobs_size() const {
  return blobs_.size();
}
inline void V0LayerParameter::clear_blobs() {
  blobs_.Clear();
}
inline const ::caffe::BlobProto& V0LayerParameter::blobs(int index) const {
  return blobs_.Get(index);
}
inline ::caffe::BlobProto* V0LayerParameter::mutable_blobs(int index) {
  return blobs_.Mutable(index);
}
inline ::caffe::BlobProto* V0LayerParameter::add_blobs() {
  return blobs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >&
V0LayerParameter::blobs() const {
  return blobs_;
}
inline ::google::protobuf::RepeatedPtrField< ::caffe::BlobProto >*
V0LayerParameter::mutable_blobs() {
  return &blobs_;
}

// repeated float blobs_lr = 51;
inline int V0LayerParameter::blobs_lr_size() const {
  return blobs_lr_.size();
}
inline void V0LayerParameter::clear_blobs_lr() {
  blobs_lr_.Clear();
}
inline float V0LayerParameter::blobs_lr(int index) const {
  return blobs_lr_.Get(index);
}
inline void V0LayerParameter::set_blobs_lr(int index, float value) {
  blobs_lr_.Set(index, value);
}
inline void V0LayerParameter::add_blobs_lr(float value) {
  blobs_lr_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
V0LayerParameter::blobs_lr() const {
  return blobs_lr_;
}
inline ::google::protobuf::RepeatedField< float >*
V0LayerParameter::mutable_blobs_lr() {
  return &blobs_lr_;
}

// repeated float weight_decay = 52;
inline int V0LayerParameter::weight_decay_size() const {
  return weight_decay_.size();
}
inline void V0LayerParameter::clear_weight_decay() {
  weight_decay_.Clear();
}
inline float V0LayerParameter::weight_decay(int index) const {
  return weight_decay_.Get(index);
}
inline void V0LayerParameter::set_weight_decay(int index, float value) {
  weight_decay_.Set(index, value);
}
inline void V0LayerParameter::add_weight_decay(float value) {
  weight_decay_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
V0LayerParameter::weight_decay() const {
  return weight_decay_;
}
inline ::google::protobuf::RepeatedField< float >*
V0LayerParameter::mutable_weight_decay() {
  return &weight_decay_;
}

// optional uint32 rand_skip = 53 [default = 0];
inline bool V0LayerParameter::has_rand_skip() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void V0LayerParameter::set_has_rand_skip() {
  _has_bits_[0] |= 0x02000000u;
}
inline void V0LayerParameter::clear_has_rand_skip() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void V0LayerParameter::clear_rand_skip() {
  rand_skip_ = 0u;
  clear_has_rand_skip();
}
inline ::google::protobuf::uint32 V0LayerParameter::rand_skip() const {
  return rand_skip_;
}
inline void V0LayerParameter::set_rand_skip(::google::protobuf::uint32 value) {
  set_has_rand_skip();
  rand_skip_ = value;
}

// optional float det_fg_threshold = 54 [default = 0.5];
inline bool V0LayerParameter::has_det_fg_threshold() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void V0LayerParameter::set_has_det_fg_threshold() {
  _has_bits_[0] |= 0x04000000u;
}
inline void V0LayerParameter::clear_has_det_fg_threshold() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void V0LayerParameter::clear_det_fg_threshold() {
  det_fg_threshold_ = 0.5f;
  clear_has_det_fg_threshold();
}
inline float V0LayerParameter::det_fg_threshold() const {
  return det_fg_threshold_;
}
inline void V0LayerParameter::set_det_fg_threshold(float value) {
  set_has_det_fg_threshold();
  det_fg_threshold_ = value;
}

// optional float det_bg_threshold = 55 [default = 0.5];
inline bool V0LayerParameter::has_det_bg_threshold() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void V0LayerParameter::set_has_det_bg_threshold() {
  _has_bits_[0] |= 0x08000000u;
}
inline void V0LayerParameter::clear_has_det_bg_threshold() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void V0LayerParameter::clear_det_bg_threshold() {
  det_bg_threshold_ = 0.5f;
  clear_has_det_bg_threshold();
}
inline float V0LayerParameter::det_bg_threshold() const {
  return det_bg_threshold_;
}
inline void V0LayerParameter::set_det_bg_threshold(float value) {
  set_has_det_bg_threshold();
  det_bg_threshold_ = value;
}

// optional float det_fg_fraction = 56 [default = 0.25];
inline bool V0LayerParameter::has_det_fg_fraction() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void V0LayerParameter::set_has_det_fg_fraction() {
  _has_bits_[0] |= 0x10000000u;
}
inline void V0LayerParameter::clear_has_det_fg_fraction() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void V0LayerParameter::clear_det_fg_fraction() {
  det_fg_fraction_ = 0.25f;
  clear_has_det_fg_fraction();
}
inline float V0LayerParameter::det_fg_fraction() const {
  return det_fg_fraction_;
}
inline void V0LayerParameter::set_det_fg_fraction(float value) {
  set_has_det_fg_fraction();
  det_fg_fraction_ = value;
}

// optional uint32 det_context_pad = 58 [default = 0];
inline bool V0LayerParameter::has_det_context_pad() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void V0LayerParameter::set_has_det_context_pad() {
  _has_bits_[0] |= 0x20000000u;
}
inline void V0LayerParameter::clear_has_det_context_pad() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void V0LayerParameter::clear_det_context_pad() {
  det_context_pad_ = 0u;
  clear_has_det_context_pad();
}
inline ::google::protobuf::uint32 V0LayerParameter::det_context_pad() const {
  return det_context_pad_;
}
inline void V0LayerParameter::set_det_context_pad(::google::protobuf::uint32 value) {
  set_has_det_context_pad();
  det_context_pad_ = value;
}

// optional string det_crop_mode = 59 [default = "warp"];
inline bool V0LayerParameter::has_det_crop_mode() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void V0LayerParameter::set_has_det_crop_mode() {
  _has_bits_[0] |= 0x40000000u;
}
inline void V0LayerParameter::clear_has_det_crop_mode() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void V0LayerParameter::clear_det_crop_mode() {
  if (det_crop_mode_ != _default_det_crop_mode_) {
    det_crop_mode_->assign(*_default_det_crop_mode_);
  }
  clear_has_det_crop_mode();
}
inline const ::std::string& V0LayerParameter::det_crop_mode() const {
  return *det_crop_mode_;
}
inline void V0LayerParameter::set_det_crop_mode(const ::std::string& value) {
  set_has_det_crop_mode();
  if (det_crop_mode_ == _default_det_crop_mode_) {
    det_crop_mode_ = new ::std::string;
  }
  det_crop_mode_->assign(value);
}
inline void V0LayerParameter::set_det_crop_mode(const char* value) {
  set_has_det_crop_mode();
  if (det_crop_mode_ == _default_det_crop_mode_) {
    det_crop_mode_ = new ::std::string;
  }
  det_crop_mode_->assign(value);
}
inline void V0LayerParameter::set_det_crop_mode(const char* value, size_t size) {
  set_has_det_crop_mode();
  if (det_crop_mode_ == _default_det_crop_mode_) {
    det_crop_mode_ = new ::std::string;
  }
  det_crop_mode_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* V0LayerParameter::mutable_det_crop_mode() {
  set_has_det_crop_mode();
  if (det_crop_mode_ == _default_det_crop_mode_) {
    det_crop_mode_ = new ::std::string(*_default_det_crop_mode_);
  }
  return det_crop_mode_;
}
inline ::std::string* V0LayerParameter::release_det_crop_mode() {
  clear_has_det_crop_mode();
  if (det_crop_mode_ == _default_det_crop_mode_) {
    return NULL;
  } else {
    ::std::string* temp = det_crop_mode_;
    det_crop_mode_ = const_cast< ::std::string*>(_default_det_crop_mode_);
    return temp;
  }
}
inline void V0LayerParameter::set_allocated_det_crop_mode(::std::string* det_crop_mode) {
  if (det_crop_mode_ != _default_det_crop_mode_) {
    delete det_crop_mode_;
  }
  if (det_crop_mode) {
    set_has_det_crop_mode();
    det_crop_mode_ = det_crop_mode;
  } else {
    clear_has_det_crop_mode();
    det_crop_mode_ = const_cast< ::std::string*>(_default_det_crop_mode_);
  }
}

// optional int32 new_num = 60 [default = 0];
inline bool V0LayerParameter::has_new_num() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void V0LayerParameter::set_has_new_num() {
  _has_bits_[0] |= 0x80000000u;
}
inline void V0LayerParameter::clear_has_new_num() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void V0LayerParameter::clear_new_num() {
  new_num_ = 0;
  clear_has_new_num();
}
inline ::google::protobuf::int32 V0LayerParameter::new_num() const {
  return new_num_;
}
inline void V0LayerParameter::set_new_num(::google::protobuf::int32 value) {
  set_has_new_num();
  new_num_ = value;
}

// optional int32 new_channels = 61 [default = 0];
inline bool V0LayerParameter::has_new_channels() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void V0LayerParameter::set_has_new_channels() {
  _has_bits_[1] |= 0x00000001u;
}
inline void V0LayerParameter::clear_has_new_channels() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void V0LayerParameter::clear_new_channels() {
  new_channels_ = 0;
  clear_has_new_channels();
}
inline ::google::protobuf::int32 V0LayerParameter::new_channels() const {
  return new_channels_;
}
inline void V0LayerParameter::set_new_channels(::google::protobuf::int32 value) {
  set_has_new_channels();
  new_channels_ = value;
}

// optional int32 new_height = 62 [default = 0];
inline bool V0LayerParameter::has_new_height() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void V0LayerParameter::set_has_new_height() {
  _has_bits_[1] |= 0x00000002u;
}
inline void V0LayerParameter::clear_has_new_height() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void V0LayerParameter::clear_new_height() {
  new_height_ = 0;
  clear_has_new_height();
}
inline ::google::protobuf::int32 V0LayerParameter::new_height() const {
  return new_height_;
}
inline void V0LayerParameter::set_new_height(::google::protobuf::int32 value) {
  set_has_new_height();
  new_height_ = value;
}

// optional int32 new_width = 63 [default = 0];
inline bool V0LayerParameter::has_new_width() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void V0LayerParameter::set_has_new_width() {
  _has_bits_[1] |= 0x00000004u;
}
inline void V0LayerParameter::clear_has_new_width() {
  _has_bits_[1] &= ~0x00000004u;
}
inline void V0LayerParameter::clear_new_width() {
  new_width_ = 0;
  clear_has_new_width();
}
inline ::google::protobuf::int32 V0LayerParameter::new_width() const {
  return new_width_;
}
inline void V0LayerParameter::set_new_width(::google::protobuf::int32 value) {
  set_has_new_width();
  new_width_ = value;
}

// optional bool shuffle_images = 64 [default = false];
inline bool V0LayerParameter::has_shuffle_images() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void V0LayerParameter::set_has_shuffle_images() {
  _has_bits_[1] |= 0x00000008u;
}
inline void V0LayerParameter::clear_has_shuffle_images() {
  _has_bits_[1] &= ~0x00000008u;
}
inline void V0LayerParameter::clear_shuffle_images() {
  shuffle_images_ = false;
  clear_has_shuffle_images();
}
inline bool V0LayerParameter::shuffle_images() const {
  return shuffle_images_;
}
inline void V0LayerParameter::set_shuffle_images(bool value) {
  set_has_shuffle_images();
  shuffle_images_ = value;
}

// optional uint32 concat_dim = 65 [default = 1];
inline bool V0LayerParameter::has_concat_dim() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void V0LayerParameter::set_has_concat_dim() {
  _has_bits_[1] |= 0x00000010u;
}
inline void V0LayerParameter::clear_has_concat_dim() {
  _has_bits_[1] &= ~0x00000010u;
}
inline void V0LayerParameter::clear_concat_dim() {
  concat_dim_ = 1u;
  clear_has_concat_dim();
}
inline ::google::protobuf::uint32 V0LayerParameter::concat_dim() const {
  return concat_dim_;
}
inline void V0LayerParameter::set_concat_dim(::google::protobuf::uint32 value) {
  set_has_concat_dim();
  concat_dim_ = value;
}

// optional .caffe.HDF5OutputParameter hdf5_output_param = 1001;
inline bool V0LayerParameter::has_hdf5_output_param() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void V0LayerParameter::set_has_hdf5_output_param() {
  _has_bits_[1] |= 0x00000020u;
}
inline void V0LayerParameter::clear_has_hdf5_output_param() {
  _has_bits_[1] &= ~0x00000020u;
}
inline void V0LayerParameter::clear_hdf5_output_param() {
  if (hdf5_output_param_ != NULL) hdf5_output_param_->::caffe::HDF5OutputParameter::Clear();
  clear_has_hdf5_output_param();
}
inline const ::caffe::HDF5OutputParameter& V0LayerParameter::hdf5_output_param() const {
  return hdf5_output_param_ != NULL ? *hdf5_output_param_ : *default_instance_->hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* V0LayerParameter::mutable_hdf5_output_param() {
  set_has_hdf5_output_param();
  if (hdf5_output_param_ == NULL) hdf5_output_param_ = new ::caffe::HDF5OutputParameter;
  return hdf5_output_param_;
}
inline ::caffe::HDF5OutputParameter* V0LayerParameter::release_hdf5_output_param() {
  clear_has_hdf5_output_param();
  ::caffe::HDF5OutputParameter* temp = hdf5_output_param_;
  hdf5_output_param_ = NULL;
  return temp;
}
inline void V0LayerParameter::set_allocated_hdf5_output_param(::caffe::HDF5OutputParameter* hdf5_output_param) {
  delete hdf5_output_param_;
  hdf5_output_param_ = hdf5_output_param;
  if (hdf5_output_param) {
    set_has_hdf5_output_param();
  } else {
    clear_has_hdf5_output_param();
  }
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace caffe

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SolverMode>() {
  return ::caffe::SolverParameter_SolverMode_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SolverParameter_SolverType>() {
  return ::caffe::SolverParameter_SolverType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LayerParameter_LayerType>() {
  return ::caffe::LayerParameter_LayerType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LayerParameter_DimCheckMode>() {
  return ::caffe::LayerParameter_DimCheckMode_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ConvolutionParameter_Engine>() {
  return ::caffe::ConvolutionParameter_Engine_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::MultiStageMeanfieldParameter_Mode>() {
  return ::caffe::MultiStageMeanfieldParameter_Mode_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::DataParameter_DB>() {
  return ::caffe::DataParameter_DB_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::EltwiseParameter_EltwiseOp>() {
  return ::caffe::EltwiseParameter_EltwiseOp_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::HingeLossParameter_Norm>() {
  return ::caffe::HingeLossParameter_Norm_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::LRNParameter_NormRegion>() {
  return ::caffe::LRNParameter_NormRegion_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_PoolMethod>() {
  return ::caffe::PoolingParameter_PoolMethod_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::PoolingParameter_Engine>() {
  return ::caffe::PoolingParameter_Engine_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::ReLUParameter_Engine>() {
  return ::caffe::ReLUParameter_Engine_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SigmoidParameter_Engine>() {
  return ::caffe::SigmoidParameter_Engine_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::SoftmaxParameter_Engine>() {
  return ::caffe::SoftmaxParameter_Engine_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::TanHParameter_Engine>() {
  return ::caffe::TanHParameter_Engine_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::V0LayerParameter_PoolMethod>() {
  return ::caffe::V0LayerParameter_PoolMethod_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe::Phase>() {
  return ::caffe::Phase_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_caffe_2eproto__INCLUDED