// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: second/protos/activations.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2factivations_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2factivations_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_second_2fprotos_2factivations_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_second_2fprotos_2factivations_2eproto;
namespace second {
namespace protos {
class Activation;
struct ActivationDefaultTypeInternal;
extern ActivationDefaultTypeInternal _Activation_default_instance_;
class ELU;
struct ELUDefaultTypeInternal;
extern ELUDefaultTypeInternal _ELU_default_instance_;
class LeakyReLU;
struct LeakyReLUDefaultTypeInternal;
extern LeakyReLUDefaultTypeInternal _LeakyReLU_default_instance_;
class ReLU;
struct ReLUDefaultTypeInternal;
extern ReLUDefaultTypeInternal _ReLU_default_instance_;
class ReLU6;
struct ReLU6DefaultTypeInternal;
extern ReLU6DefaultTypeInternal _ReLU6_default_instance_;
class SELU;
struct SELUDefaultTypeInternal;
extern SELUDefaultTypeInternal _SELU_default_instance_;
class Softplus;
struct SoftplusDefaultTypeInternal;
extern SoftplusDefaultTypeInternal _Softplus_default_instance_;
class Softsign;
struct SoftsignDefaultTypeInternal;
extern SoftsignDefaultTypeInternal _Softsign_default_instance_;
class Swish;
struct SwishDefaultTypeInternal;
extern SwishDefaultTypeInternal _Swish_default_instance_;
}  // namespace protos
}  // namespace second
PROTOBUF_NAMESPACE_OPEN
template<> ::second::protos::Activation* Arena::CreateMaybeMessage<::second::protos::Activation>(Arena*);
template<> ::second::protos::ELU* Arena::CreateMaybeMessage<::second::protos::ELU>(Arena*);
template<> ::second::protos::LeakyReLU* Arena::CreateMaybeMessage<::second::protos::LeakyReLU>(Arena*);
template<> ::second::protos::ReLU* Arena::CreateMaybeMessage<::second::protos::ReLU>(Arena*);
template<> ::second::protos::ReLU6* Arena::CreateMaybeMessage<::second::protos::ReLU6>(Arena*);
template<> ::second::protos::SELU* Arena::CreateMaybeMessage<::second::protos::SELU>(Arena*);
template<> ::second::protos::Softplus* Arena::CreateMaybeMessage<::second::protos::Softplus>(Arena*);
template<> ::second::protos::Softsign* Arena::CreateMaybeMessage<::second::protos::Softsign>(Arena*);
template<> ::second::protos::Swish* Arena::CreateMaybeMessage<::second::protos::Swish>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace second {
namespace protos {

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

class ReLU final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:second.protos.ReLU) */ {
 public:
  inline ReLU() : ReLU(nullptr) {}
  explicit PROTOBUF_CONSTEXPR ReLU(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ReLU& operator=(const ReLU& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReLU& operator=(ReLU&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  ReLU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReLU>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const ReLU& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const ReLU& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ReLU";
  }
  protected:
  explicit ReLU(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  // @@protoc_insertion_point(class_scope:second.protos.ReLU)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline LeakyReLU& operator=(const LeakyReLU& from) {
    CopyFrom(from);
    return *this;
  }
  inline LeakyReLU& operator=(LeakyReLU&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  LeakyReLU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LeakyReLU>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LeakyReLU& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LeakyReLU& from) {
    LeakyReLU::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.LeakyReLU";
  }
  protected:
  explicit LeakyReLU(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kLeaknessFieldNumber = 1,
  };
  // float leakness = 1;
  void clear_leakness();
  float leakness() const;
  void set_leakness(float value);
  private:
  float _internal_leakness() const;
  void _internal_set_leakness(float value);
  public:

  // @@protoc_insertion_point(class_scope:second.protos.LeakyReLU)
 private:
  class _Internal;

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

class Swish final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:second.protos.Swish) */ {
 public:
  inline Swish() : Swish(nullptr) {}
  explicit PROTOBUF_CONSTEXPR Swish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Swish& operator=(const Swish& from) {
    CopyFrom(from);
    return *this;
  }
  inline Swish& operator=(Swish&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  Swish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Swish>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const Swish& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const Swish& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.Swish";
  }
  protected:
  explicit Swish(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  // @@protoc_insertion_point(class_scope:second.protos.Swish)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ELU& operator=(const ELU& from) {
    CopyFrom(from);
    return *this;
  }
  inline ELU& operator=(ELU&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  ELU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ELU>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ELU& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ELU& from) {
    ELU::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ELU";
  }
  protected:
  explicit ELU(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kAlphaFieldNumber = 1,
  };
  // float alpha = 1;
  void clear_alpha();
  float alpha() const;
  void set_alpha(float value);
  private:
  float _internal_alpha() const;
  void _internal_set_alpha(float value);
  public:

  // @@protoc_insertion_point(class_scope:second.protos.ELU)
 private:
  class _Internal;

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

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

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

  inline Softplus& operator=(const Softplus& from) {
    CopyFrom(from);
    return *this;
  }
  inline Softplus& operator=(Softplus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  Softplus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Softplus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Softplus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Softplus& from) {
    Softplus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.Softplus";
  }
  protected:
  explicit Softplus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kBetaFieldNumber = 1,
    kThresholdFieldNumber = 2,
  };
  // float beta = 1;
  void clear_beta();
  float beta() const;
  void set_beta(float value);
  private:
  float _internal_beta() const;
  void _internal_set_beta(float value);
  public:

  // float threshold = 2;
  void clear_threshold();
  float threshold() const;
  void set_threshold(float value);
  private:
  float _internal_threshold() const;
  void _internal_set_threshold(float value);
  public:

  // @@protoc_insertion_point(class_scope:second.protos.Softplus)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    float beta_;
    float threshold_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// -------------------------------------------------------------------

class Softsign final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:second.protos.Softsign) */ {
 public:
  inline Softsign() : Softsign(nullptr) {}
  explicit PROTOBUF_CONSTEXPR Softsign(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Softsign& operator=(const Softsign& from) {
    CopyFrom(from);
    return *this;
  }
  inline Softsign& operator=(Softsign&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  Softsign* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Softsign>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const Softsign& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const Softsign& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.Softsign";
  }
  protected:
  explicit Softsign(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  // @@protoc_insertion_point(class_scope:second.protos.Softsign)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// -------------------------------------------------------------------

class ReLU6 final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:second.protos.ReLU6) */ {
 public:
  inline ReLU6() : ReLU6(nullptr) {}
  explicit PROTOBUF_CONSTEXPR ReLU6(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ReLU6& operator=(const ReLU6& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReLU6& operator=(ReLU6&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

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

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

  ReLU6* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReLU6>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const ReLU6& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const ReLU6& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.ReLU6";
  }
  protected:
  explicit ReLU6(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  // @@protoc_insertion_point(class_scope:second.protos.ReLU6)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// -------------------------------------------------------------------

class SELU final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:second.protos.SELU) */ {
 public:
  inline SELU() : SELU(nullptr) {}
  explicit PROTOBUF_CONSTEXPR SELU(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SELU& operator=(const SELU& from) {
    CopyFrom(from);
    return *this;
  }
  inline SELU& operator=(SELU&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SELU& default_instance() {
    return *internal_default_instance();
  }
  static inline const SELU* internal_default_instance() {
    return reinterpret_cast<const SELU*>(
               &_SELU_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

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

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

  SELU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SELU>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const SELU& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const SELU& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.SELU";
  }
  protected:
  explicit SELU(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  // @@protoc_insertion_point(class_scope:second.protos.SELU)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Activation& operator=(const Activation& from) {
    CopyFrom(from);
    return *this;
  }
  inline Activation& operator=(Activation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Activation& default_instance() {
    return *internal_default_instance();
  }
  enum ActivationCase {
    kRelu = 1,
    kLeakyRelu = 2,
    kSwish = 3,
    kElu = 4,
    kSoftplus = 5,
    kSoftsign = 6,
    kRelu6 = 7,
    kSelu = 8,
    ACTIVATION_NOT_SET = 0,
  };

  static inline const Activation* internal_default_instance() {
    return reinterpret_cast<const Activation*>(
               &_Activation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

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

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

  Activation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Activation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Activation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Activation& from) {
    Activation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.Activation";
  }
  protected:
  explicit Activation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kReluFieldNumber = 1,
    kLeakyReluFieldNumber = 2,
    kSwishFieldNumber = 3,
    kEluFieldNumber = 4,
    kSoftplusFieldNumber = 5,
    kSoftsignFieldNumber = 6,
    kRelu6FieldNumber = 7,
    kSeluFieldNumber = 8,
  };
  // .second.protos.ReLU relu = 1;
  bool has_relu() const;
  private:
  bool _internal_has_relu() const;
  public:
  void clear_relu();
  const ::second::protos::ReLU& relu() const;
  PROTOBUF_NODISCARD ::second::protos::ReLU* release_relu();
  ::second::protos::ReLU* mutable_relu();
  void set_allocated_relu(::second::protos::ReLU* relu);
  private:
  const ::second::protos::ReLU& _internal_relu() const;
  ::second::protos::ReLU* _internal_mutable_relu();
  public:
  void unsafe_arena_set_allocated_relu(
      ::second::protos::ReLU* relu);
  ::second::protos::ReLU* unsafe_arena_release_relu();

  // .second.protos.LeakyReLU leaky_relu = 2;
  bool has_leaky_relu() const;
  private:
  bool _internal_has_leaky_relu() const;
  public:
  void clear_leaky_relu();
  const ::second::protos::LeakyReLU& leaky_relu() const;
  PROTOBUF_NODISCARD ::second::protos::LeakyReLU* release_leaky_relu();
  ::second::protos::LeakyReLU* mutable_leaky_relu();
  void set_allocated_leaky_relu(::second::protos::LeakyReLU* leaky_relu);
  private:
  const ::second::protos::LeakyReLU& _internal_leaky_relu() const;
  ::second::protos::LeakyReLU* _internal_mutable_leaky_relu();
  public:
  void unsafe_arena_set_allocated_leaky_relu(
      ::second::protos::LeakyReLU* leaky_relu);
  ::second::protos::LeakyReLU* unsafe_arena_release_leaky_relu();

  // .second.protos.Swish swish = 3;
  bool has_swish() const;
  private:
  bool _internal_has_swish() const;
  public:
  void clear_swish();
  const ::second::protos::Swish& swish() const;
  PROTOBUF_NODISCARD ::second::protos::Swish* release_swish();
  ::second::protos::Swish* mutable_swish();
  void set_allocated_swish(::second::protos::Swish* swish);
  private:
  const ::second::protos::Swish& _internal_swish() const;
  ::second::protos::Swish* _internal_mutable_swish();
  public:
  void unsafe_arena_set_allocated_swish(
      ::second::protos::Swish* swish);
  ::second::protos::Swish* unsafe_arena_release_swish();

  // .second.protos.ELU elu = 4;
  bool has_elu() const;
  private:
  bool _internal_has_elu() const;
  public:
  void clear_elu();
  const ::second::protos::ELU& elu() const;
  PROTOBUF_NODISCARD ::second::protos::ELU* release_elu();
  ::second::protos::ELU* mutable_elu();
  void set_allocated_elu(::second::protos::ELU* elu);
  private:
  const ::second::protos::ELU& _internal_elu() const;
  ::second::protos::ELU* _internal_mutable_elu();
  public:
  void unsafe_arena_set_allocated_elu(
      ::second::protos::ELU* elu);
  ::second::protos::ELU* unsafe_arena_release_elu();

  // .second.protos.Softplus softplus = 5;
  bool has_softplus() const;
  private:
  bool _internal_has_softplus() const;
  public:
  void clear_softplus();
  const ::second::protos::Softplus& softplus() const;
  PROTOBUF_NODISCARD ::second::protos::Softplus* release_softplus();
  ::second::protos::Softplus* mutable_softplus();
  void set_allocated_softplus(::second::protos::Softplus* softplus);
  private:
  const ::second::protos::Softplus& _internal_softplus() const;
  ::second::protos::Softplus* _internal_mutable_softplus();
  public:
  void unsafe_arena_set_allocated_softplus(
      ::second::protos::Softplus* softplus);
  ::second::protos::Softplus* unsafe_arena_release_softplus();

  // .second.protos.Softsign softsign = 6;
  bool has_softsign() const;
  private:
  bool _internal_has_softsign() const;
  public:
  void clear_softsign();
  const ::second::protos::Softsign& softsign() const;
  PROTOBUF_NODISCARD ::second::protos::Softsign* release_softsign();
  ::second::protos::Softsign* mutable_softsign();
  void set_allocated_softsign(::second::protos::Softsign* softsign);
  private:
  const ::second::protos::Softsign& _internal_softsign() const;
  ::second::protos::Softsign* _internal_mutable_softsign();
  public:
  void unsafe_arena_set_allocated_softsign(
      ::second::protos::Softsign* softsign);
  ::second::protos::Softsign* unsafe_arena_release_softsign();

  // .second.protos.ReLU6 relu6 = 7;
  bool has_relu6() const;
  private:
  bool _internal_has_relu6() const;
  public:
  void clear_relu6();
  const ::second::protos::ReLU6& relu6() const;
  PROTOBUF_NODISCARD ::second::protos::ReLU6* release_relu6();
  ::second::protos::ReLU6* mutable_relu6();
  void set_allocated_relu6(::second::protos::ReLU6* relu6);
  private:
  const ::second::protos::ReLU6& _internal_relu6() const;
  ::second::protos::ReLU6* _internal_mutable_relu6();
  public:
  void unsafe_arena_set_allocated_relu6(
      ::second::protos::ReLU6* relu6);
  ::second::protos::ReLU6* unsafe_arena_release_relu6();

  // .second.protos.SELU selu = 8;
  bool has_selu() const;
  private:
  bool _internal_has_selu() const;
  public:
  void clear_selu();
  const ::second::protos::SELU& selu() const;
  PROTOBUF_NODISCARD ::second::protos::SELU* release_selu();
  ::second::protos::SELU* mutable_selu();
  void set_allocated_selu(::second::protos::SELU* selu);
  private:
  const ::second::protos::SELU& _internal_selu() const;
  ::second::protos::SELU* _internal_mutable_selu();
  public:
  void unsafe_arena_set_allocated_selu(
      ::second::protos::SELU* selu);
  ::second::protos::SELU* unsafe_arena_release_selu();

  void clear_activation();
  ActivationCase activation_case() const;
  // @@protoc_insertion_point(class_scope:second.protos.Activation)
 private:
  class _Internal;
  void set_has_relu();
  void set_has_leaky_relu();
  void set_has_swish();
  void set_has_elu();
  void set_has_softplus();
  void set_has_softsign();
  void set_has_relu6();
  void set_has_selu();

  inline bool has_activation() const;
  inline void clear_has_activation();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ActivationUnion {
      constexpr ActivationUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::second::protos::ReLU* relu_;
      ::second::protos::LeakyReLU* leaky_relu_;
      ::second::protos::Swish* swish_;
      ::second::protos::ELU* elu_;
      ::second::protos::Softplus* softplus_;
      ::second::protos::Softsign* softsign_;
      ::second::protos::ReLU6* relu6_;
      ::second::protos::SELU* selu_;
    } activation_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2factivations_2eproto;
};
// ===================================================================


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

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

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

// LeakyReLU

// float leakness = 1;
inline void LeakyReLU::clear_leakness() {
  _impl_.leakness_ = 0;
}
inline float LeakyReLU::_internal_leakness() const {
  return _impl_.leakness_;
}
inline float LeakyReLU::leakness() const {
  // @@protoc_insertion_point(field_get:second.protos.LeakyReLU.leakness)
  return _internal_leakness();
}
inline void LeakyReLU::_internal_set_leakness(float value) {
  
  _impl_.leakness_ = value;
}
inline void LeakyReLU::set_leakness(float value) {
  _internal_set_leakness(value);
  // @@protoc_insertion_point(field_set:second.protos.LeakyReLU.leakness)
}

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

// Swish

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

// ELU

// float alpha = 1;
inline void ELU::clear_alpha() {
  _impl_.alpha_ = 0;
}
inline float ELU::_internal_alpha() const {
  return _impl_.alpha_;
}
inline float ELU::alpha() const {
  // @@protoc_insertion_point(field_get:second.protos.ELU.alpha)
  return _internal_alpha();
}
inline void ELU::_internal_set_alpha(float value) {
  
  _impl_.alpha_ = value;
}
inline void ELU::set_alpha(float value) {
  _internal_set_alpha(value);
  // @@protoc_insertion_point(field_set:second.protos.ELU.alpha)
}

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

// Softplus

// float beta = 1;
inline void Softplus::clear_beta() {
  _impl_.beta_ = 0;
}
inline float Softplus::_internal_beta() const {
  return _impl_.beta_;
}
inline float Softplus::beta() const {
  // @@protoc_insertion_point(field_get:second.protos.Softplus.beta)
  return _internal_beta();
}
inline void Softplus::_internal_set_beta(float value) {
  
  _impl_.beta_ = value;
}
inline void Softplus::set_beta(float value) {
  _internal_set_beta(value);
  // @@protoc_insertion_point(field_set:second.protos.Softplus.beta)
}

// float threshold = 2;
inline void Softplus::clear_threshold() {
  _impl_.threshold_ = 0;
}
inline float Softplus::_internal_threshold() const {
  return _impl_.threshold_;
}
inline float Softplus::threshold() const {
  // @@protoc_insertion_point(field_get:second.protos.Softplus.threshold)
  return _internal_threshold();
}
inline void Softplus::_internal_set_threshold(float value) {
  
  _impl_.threshold_ = value;
}
inline void Softplus::set_threshold(float value) {
  _internal_set_threshold(value);
  // @@protoc_insertion_point(field_set:second.protos.Softplus.threshold)
}

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

// Softsign

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

// ReLU6

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

// SELU

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

// Activation

// .second.protos.ReLU relu = 1;
inline bool Activation::_internal_has_relu() const {
  return activation_case() == kRelu;
}
inline bool Activation::has_relu() const {
  return _internal_has_relu();
}
inline void Activation::set_has_relu() {
  _impl_._oneof_case_[0] = kRelu;
}
inline void Activation::clear_relu() {
  if (_internal_has_relu()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.relu_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::ReLU* Activation::release_relu() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.relu)
  if (_internal_has_relu()) {
    clear_has_activation();
    ::second::protos::ReLU* temp = _impl_.activation_.relu_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.relu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::ReLU& Activation::_internal_relu() const {
  return _internal_has_relu()
      ? *_impl_.activation_.relu_
      : reinterpret_cast< ::second::protos::ReLU&>(::second::protos::_ReLU_default_instance_);
}
inline const ::second::protos::ReLU& Activation::relu() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.relu)
  return _internal_relu();
}
inline ::second::protos::ReLU* Activation::unsafe_arena_release_relu() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.relu)
  if (_internal_has_relu()) {
    clear_has_activation();
    ::second::protos::ReLU* temp = _impl_.activation_.relu_;
    _impl_.activation_.relu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_relu(::second::protos::ReLU* relu) {
  clear_activation();
  if (relu) {
    set_has_relu();
    _impl_.activation_.relu_ = relu;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.relu)
}
inline ::second::protos::ReLU* Activation::_internal_mutable_relu() {
  if (!_internal_has_relu()) {
    clear_activation();
    set_has_relu();
    _impl_.activation_.relu_ = CreateMaybeMessage< ::second::protos::ReLU >(GetArenaForAllocation());
  }
  return _impl_.activation_.relu_;
}
inline ::second::protos::ReLU* Activation::mutable_relu() {
  ::second::protos::ReLU* _msg = _internal_mutable_relu();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.relu)
  return _msg;
}

// .second.protos.LeakyReLU leaky_relu = 2;
inline bool Activation::_internal_has_leaky_relu() const {
  return activation_case() == kLeakyRelu;
}
inline bool Activation::has_leaky_relu() const {
  return _internal_has_leaky_relu();
}
inline void Activation::set_has_leaky_relu() {
  _impl_._oneof_case_[0] = kLeakyRelu;
}
inline void Activation::clear_leaky_relu() {
  if (_internal_has_leaky_relu()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.leaky_relu_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::LeakyReLU* Activation::release_leaky_relu() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.leaky_relu)
  if (_internal_has_leaky_relu()) {
    clear_has_activation();
    ::second::protos::LeakyReLU* temp = _impl_.activation_.leaky_relu_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.leaky_relu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::LeakyReLU& Activation::_internal_leaky_relu() const {
  return _internal_has_leaky_relu()
      ? *_impl_.activation_.leaky_relu_
      : reinterpret_cast< ::second::protos::LeakyReLU&>(::second::protos::_LeakyReLU_default_instance_);
}
inline const ::second::protos::LeakyReLU& Activation::leaky_relu() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.leaky_relu)
  return _internal_leaky_relu();
}
inline ::second::protos::LeakyReLU* Activation::unsafe_arena_release_leaky_relu() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.leaky_relu)
  if (_internal_has_leaky_relu()) {
    clear_has_activation();
    ::second::protos::LeakyReLU* temp = _impl_.activation_.leaky_relu_;
    _impl_.activation_.leaky_relu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_leaky_relu(::second::protos::LeakyReLU* leaky_relu) {
  clear_activation();
  if (leaky_relu) {
    set_has_leaky_relu();
    _impl_.activation_.leaky_relu_ = leaky_relu;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.leaky_relu)
}
inline ::second::protos::LeakyReLU* Activation::_internal_mutable_leaky_relu() {
  if (!_internal_has_leaky_relu()) {
    clear_activation();
    set_has_leaky_relu();
    _impl_.activation_.leaky_relu_ = CreateMaybeMessage< ::second::protos::LeakyReLU >(GetArenaForAllocation());
  }
  return _impl_.activation_.leaky_relu_;
}
inline ::second::protos::LeakyReLU* Activation::mutable_leaky_relu() {
  ::second::protos::LeakyReLU* _msg = _internal_mutable_leaky_relu();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.leaky_relu)
  return _msg;
}

// .second.protos.Swish swish = 3;
inline bool Activation::_internal_has_swish() const {
  return activation_case() == kSwish;
}
inline bool Activation::has_swish() const {
  return _internal_has_swish();
}
inline void Activation::set_has_swish() {
  _impl_._oneof_case_[0] = kSwish;
}
inline void Activation::clear_swish() {
  if (_internal_has_swish()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.swish_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::Swish* Activation::release_swish() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.swish)
  if (_internal_has_swish()) {
    clear_has_activation();
    ::second::protos::Swish* temp = _impl_.activation_.swish_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.swish_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::Swish& Activation::_internal_swish() const {
  return _internal_has_swish()
      ? *_impl_.activation_.swish_
      : reinterpret_cast< ::second::protos::Swish&>(::second::protos::_Swish_default_instance_);
}
inline const ::second::protos::Swish& Activation::swish() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.swish)
  return _internal_swish();
}
inline ::second::protos::Swish* Activation::unsafe_arena_release_swish() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.swish)
  if (_internal_has_swish()) {
    clear_has_activation();
    ::second::protos::Swish* temp = _impl_.activation_.swish_;
    _impl_.activation_.swish_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_swish(::second::protos::Swish* swish) {
  clear_activation();
  if (swish) {
    set_has_swish();
    _impl_.activation_.swish_ = swish;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.swish)
}
inline ::second::protos::Swish* Activation::_internal_mutable_swish() {
  if (!_internal_has_swish()) {
    clear_activation();
    set_has_swish();
    _impl_.activation_.swish_ = CreateMaybeMessage< ::second::protos::Swish >(GetArenaForAllocation());
  }
  return _impl_.activation_.swish_;
}
inline ::second::protos::Swish* Activation::mutable_swish() {
  ::second::protos::Swish* _msg = _internal_mutable_swish();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.swish)
  return _msg;
}

// .second.protos.ELU elu = 4;
inline bool Activation::_internal_has_elu() const {
  return activation_case() == kElu;
}
inline bool Activation::has_elu() const {
  return _internal_has_elu();
}
inline void Activation::set_has_elu() {
  _impl_._oneof_case_[0] = kElu;
}
inline void Activation::clear_elu() {
  if (_internal_has_elu()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.elu_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::ELU* Activation::release_elu() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.elu)
  if (_internal_has_elu()) {
    clear_has_activation();
    ::second::protos::ELU* temp = _impl_.activation_.elu_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.elu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::ELU& Activation::_internal_elu() const {
  return _internal_has_elu()
      ? *_impl_.activation_.elu_
      : reinterpret_cast< ::second::protos::ELU&>(::second::protos::_ELU_default_instance_);
}
inline const ::second::protos::ELU& Activation::elu() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.elu)
  return _internal_elu();
}
inline ::second::protos::ELU* Activation::unsafe_arena_release_elu() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.elu)
  if (_internal_has_elu()) {
    clear_has_activation();
    ::second::protos::ELU* temp = _impl_.activation_.elu_;
    _impl_.activation_.elu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_elu(::second::protos::ELU* elu) {
  clear_activation();
  if (elu) {
    set_has_elu();
    _impl_.activation_.elu_ = elu;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.elu)
}
inline ::second::protos::ELU* Activation::_internal_mutable_elu() {
  if (!_internal_has_elu()) {
    clear_activation();
    set_has_elu();
    _impl_.activation_.elu_ = CreateMaybeMessage< ::second::protos::ELU >(GetArenaForAllocation());
  }
  return _impl_.activation_.elu_;
}
inline ::second::protos::ELU* Activation::mutable_elu() {
  ::second::protos::ELU* _msg = _internal_mutable_elu();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.elu)
  return _msg;
}

// .second.protos.Softplus softplus = 5;
inline bool Activation::_internal_has_softplus() const {
  return activation_case() == kSoftplus;
}
inline bool Activation::has_softplus() const {
  return _internal_has_softplus();
}
inline void Activation::set_has_softplus() {
  _impl_._oneof_case_[0] = kSoftplus;
}
inline void Activation::clear_softplus() {
  if (_internal_has_softplus()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.softplus_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::Softplus* Activation::release_softplus() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.softplus)
  if (_internal_has_softplus()) {
    clear_has_activation();
    ::second::protos::Softplus* temp = _impl_.activation_.softplus_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.softplus_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::Softplus& Activation::_internal_softplus() const {
  return _internal_has_softplus()
      ? *_impl_.activation_.softplus_
      : reinterpret_cast< ::second::protos::Softplus&>(::second::protos::_Softplus_default_instance_);
}
inline const ::second::protos::Softplus& Activation::softplus() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.softplus)
  return _internal_softplus();
}
inline ::second::protos::Softplus* Activation::unsafe_arena_release_softplus() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.softplus)
  if (_internal_has_softplus()) {
    clear_has_activation();
    ::second::protos::Softplus* temp = _impl_.activation_.softplus_;
    _impl_.activation_.softplus_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_softplus(::second::protos::Softplus* softplus) {
  clear_activation();
  if (softplus) {
    set_has_softplus();
    _impl_.activation_.softplus_ = softplus;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.softplus)
}
inline ::second::protos::Softplus* Activation::_internal_mutable_softplus() {
  if (!_internal_has_softplus()) {
    clear_activation();
    set_has_softplus();
    _impl_.activation_.softplus_ = CreateMaybeMessage< ::second::protos::Softplus >(GetArenaForAllocation());
  }
  return _impl_.activation_.softplus_;
}
inline ::second::protos::Softplus* Activation::mutable_softplus() {
  ::second::protos::Softplus* _msg = _internal_mutable_softplus();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.softplus)
  return _msg;
}

// .second.protos.Softsign softsign = 6;
inline bool Activation::_internal_has_softsign() const {
  return activation_case() == kSoftsign;
}
inline bool Activation::has_softsign() const {
  return _internal_has_softsign();
}
inline void Activation::set_has_softsign() {
  _impl_._oneof_case_[0] = kSoftsign;
}
inline void Activation::clear_softsign() {
  if (_internal_has_softsign()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.softsign_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::Softsign* Activation::release_softsign() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.softsign)
  if (_internal_has_softsign()) {
    clear_has_activation();
    ::second::protos::Softsign* temp = _impl_.activation_.softsign_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.softsign_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::Softsign& Activation::_internal_softsign() const {
  return _internal_has_softsign()
      ? *_impl_.activation_.softsign_
      : reinterpret_cast< ::second::protos::Softsign&>(::second::protos::_Softsign_default_instance_);
}
inline const ::second::protos::Softsign& Activation::softsign() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.softsign)
  return _internal_softsign();
}
inline ::second::protos::Softsign* Activation::unsafe_arena_release_softsign() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.softsign)
  if (_internal_has_softsign()) {
    clear_has_activation();
    ::second::protos::Softsign* temp = _impl_.activation_.softsign_;
    _impl_.activation_.softsign_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_softsign(::second::protos::Softsign* softsign) {
  clear_activation();
  if (softsign) {
    set_has_softsign();
    _impl_.activation_.softsign_ = softsign;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.softsign)
}
inline ::second::protos::Softsign* Activation::_internal_mutable_softsign() {
  if (!_internal_has_softsign()) {
    clear_activation();
    set_has_softsign();
    _impl_.activation_.softsign_ = CreateMaybeMessage< ::second::protos::Softsign >(GetArenaForAllocation());
  }
  return _impl_.activation_.softsign_;
}
inline ::second::protos::Softsign* Activation::mutable_softsign() {
  ::second::protos::Softsign* _msg = _internal_mutable_softsign();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.softsign)
  return _msg;
}

// .second.protos.ReLU6 relu6 = 7;
inline bool Activation::_internal_has_relu6() const {
  return activation_case() == kRelu6;
}
inline bool Activation::has_relu6() const {
  return _internal_has_relu6();
}
inline void Activation::set_has_relu6() {
  _impl_._oneof_case_[0] = kRelu6;
}
inline void Activation::clear_relu6() {
  if (_internal_has_relu6()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.relu6_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::ReLU6* Activation::release_relu6() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.relu6)
  if (_internal_has_relu6()) {
    clear_has_activation();
    ::second::protos::ReLU6* temp = _impl_.activation_.relu6_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.relu6_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::ReLU6& Activation::_internal_relu6() const {
  return _internal_has_relu6()
      ? *_impl_.activation_.relu6_
      : reinterpret_cast< ::second::protos::ReLU6&>(::second::protos::_ReLU6_default_instance_);
}
inline const ::second::protos::ReLU6& Activation::relu6() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.relu6)
  return _internal_relu6();
}
inline ::second::protos::ReLU6* Activation::unsafe_arena_release_relu6() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.relu6)
  if (_internal_has_relu6()) {
    clear_has_activation();
    ::second::protos::ReLU6* temp = _impl_.activation_.relu6_;
    _impl_.activation_.relu6_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_relu6(::second::protos::ReLU6* relu6) {
  clear_activation();
  if (relu6) {
    set_has_relu6();
    _impl_.activation_.relu6_ = relu6;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.relu6)
}
inline ::second::protos::ReLU6* Activation::_internal_mutable_relu6() {
  if (!_internal_has_relu6()) {
    clear_activation();
    set_has_relu6();
    _impl_.activation_.relu6_ = CreateMaybeMessage< ::second::protos::ReLU6 >(GetArenaForAllocation());
  }
  return _impl_.activation_.relu6_;
}
inline ::second::protos::ReLU6* Activation::mutable_relu6() {
  ::second::protos::ReLU6* _msg = _internal_mutable_relu6();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.relu6)
  return _msg;
}

// .second.protos.SELU selu = 8;
inline bool Activation::_internal_has_selu() const {
  return activation_case() == kSelu;
}
inline bool Activation::has_selu() const {
  return _internal_has_selu();
}
inline void Activation::set_has_selu() {
  _impl_._oneof_case_[0] = kSelu;
}
inline void Activation::clear_selu() {
  if (_internal_has_selu()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.activation_.selu_;
    }
    clear_has_activation();
  }
}
inline ::second::protos::SELU* Activation::release_selu() {
  // @@protoc_insertion_point(field_release:second.protos.Activation.selu)
  if (_internal_has_selu()) {
    clear_has_activation();
    ::second::protos::SELU* temp = _impl_.activation_.selu_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.activation_.selu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::SELU& Activation::_internal_selu() const {
  return _internal_has_selu()
      ? *_impl_.activation_.selu_
      : reinterpret_cast< ::second::protos::SELU&>(::second::protos::_SELU_default_instance_);
}
inline const ::second::protos::SELU& Activation::selu() const {
  // @@protoc_insertion_point(field_get:second.protos.Activation.selu)
  return _internal_selu();
}
inline ::second::protos::SELU* Activation::unsafe_arena_release_selu() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.Activation.selu)
  if (_internal_has_selu()) {
    clear_has_activation();
    ::second::protos::SELU* temp = _impl_.activation_.selu_;
    _impl_.activation_.selu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Activation::unsafe_arena_set_allocated_selu(::second::protos::SELU* selu) {
  clear_activation();
  if (selu) {
    set_has_selu();
    _impl_.activation_.selu_ = selu;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.Activation.selu)
}
inline ::second::protos::SELU* Activation::_internal_mutable_selu() {
  if (!_internal_has_selu()) {
    clear_activation();
    set_has_selu();
    _impl_.activation_.selu_ = CreateMaybeMessage< ::second::protos::SELU >(GetArenaForAllocation());
  }
  return _impl_.activation_.selu_;
}
inline ::second::protos::SELU* Activation::mutable_selu() {
  ::second::protos::SELU* _msg = _internal_mutable_selu();
  // @@protoc_insertion_point(field_mutable:second.protos.Activation.selu)
  return _msg;
}

inline bool Activation::has_activation() const {
  return activation_case() != ACTIVATION_NOT_SET;
}
inline void Activation::clear_has_activation() {
  _impl_._oneof_case_[0] = ACTIVATION_NOT_SET;
}
inline Activation::ActivationCase Activation::activation_case() const {
  return Activation::ActivationCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace second

// @@protoc_insertion_point(global_scope)

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