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

#ifndef GOOGLE_PROTOBUF_INCLUDED_SVM_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_SVM_2eproto

#include <limits>
#include <string>

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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include "DataStructures.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_SVM_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_SVM_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
namespace CoreML {
namespace Specification {
class Coefficients;
struct CoefficientsDefaultTypeInternal;
extern CoefficientsDefaultTypeInternal _Coefficients_default_instance_;
class DenseSupportVectors;
struct DenseSupportVectorsDefaultTypeInternal;
extern DenseSupportVectorsDefaultTypeInternal _DenseSupportVectors_default_instance_;
class DenseVector;
struct DenseVectorDefaultTypeInternal;
extern DenseVectorDefaultTypeInternal _DenseVector_default_instance_;
class Kernel;
struct KernelDefaultTypeInternal;
extern KernelDefaultTypeInternal _Kernel_default_instance_;
class LinearKernel;
struct LinearKernelDefaultTypeInternal;
extern LinearKernelDefaultTypeInternal _LinearKernel_default_instance_;
class PolyKernel;
struct PolyKernelDefaultTypeInternal;
extern PolyKernelDefaultTypeInternal _PolyKernel_default_instance_;
class RBFKernel;
struct RBFKernelDefaultTypeInternal;
extern RBFKernelDefaultTypeInternal _RBFKernel_default_instance_;
class SigmoidKernel;
struct SigmoidKernelDefaultTypeInternal;
extern SigmoidKernelDefaultTypeInternal _SigmoidKernel_default_instance_;
class SparseNode;
struct SparseNodeDefaultTypeInternal;
extern SparseNodeDefaultTypeInternal _SparseNode_default_instance_;
class SparseSupportVectors;
struct SparseSupportVectorsDefaultTypeInternal;
extern SparseSupportVectorsDefaultTypeInternal _SparseSupportVectors_default_instance_;
class SparseVector;
struct SparseVectorDefaultTypeInternal;
extern SparseVectorDefaultTypeInternal _SparseVector_default_instance_;
class SupportVectorClassifier;
struct SupportVectorClassifierDefaultTypeInternal;
extern SupportVectorClassifierDefaultTypeInternal _SupportVectorClassifier_default_instance_;
class SupportVectorRegressor;
struct SupportVectorRegressorDefaultTypeInternal;
extern SupportVectorRegressorDefaultTypeInternal _SupportVectorRegressor_default_instance_;
}  // namespace Specification
}  // namespace CoreML
PROTOBUF_NAMESPACE_OPEN
template<> ::CoreML::Specification::Coefficients* Arena::CreateMaybeMessage<::CoreML::Specification::Coefficients>(Arena*);
template<> ::CoreML::Specification::DenseSupportVectors* Arena::CreateMaybeMessage<::CoreML::Specification::DenseSupportVectors>(Arena*);
template<> ::CoreML::Specification::DenseVector* Arena::CreateMaybeMessage<::CoreML::Specification::DenseVector>(Arena*);
template<> ::CoreML::Specification::Kernel* Arena::CreateMaybeMessage<::CoreML::Specification::Kernel>(Arena*);
template<> ::CoreML::Specification::LinearKernel* Arena::CreateMaybeMessage<::CoreML::Specification::LinearKernel>(Arena*);
template<> ::CoreML::Specification::PolyKernel* Arena::CreateMaybeMessage<::CoreML::Specification::PolyKernel>(Arena*);
template<> ::CoreML::Specification::RBFKernel* Arena::CreateMaybeMessage<::CoreML::Specification::RBFKernel>(Arena*);
template<> ::CoreML::Specification::SigmoidKernel* Arena::CreateMaybeMessage<::CoreML::Specification::SigmoidKernel>(Arena*);
template<> ::CoreML::Specification::SparseNode* Arena::CreateMaybeMessage<::CoreML::Specification::SparseNode>(Arena*);
template<> ::CoreML::Specification::SparseSupportVectors* Arena::CreateMaybeMessage<::CoreML::Specification::SparseSupportVectors>(Arena*);
template<> ::CoreML::Specification::SparseVector* Arena::CreateMaybeMessage<::CoreML::Specification::SparseVector>(Arena*);
template<> ::CoreML::Specification::SupportVectorClassifier* Arena::CreateMaybeMessage<::CoreML::Specification::SupportVectorClassifier>(Arena*);
template<> ::CoreML::Specification::SupportVectorRegressor* Arena::CreateMaybeMessage<::CoreML::Specification::SupportVectorRegressor>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace CoreML {
namespace Specification {

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

class LinearKernel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.LinearKernel) */ {
 public:
  inline LinearKernel() : LinearKernel(nullptr) {}
  ~LinearKernel() override;
  explicit constexpr LinearKernel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  LinearKernel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinearKernel>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const LinearKernel& from);
  void MergeFrom(const LinearKernel& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:CoreML.Specification.LinearKernel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class RBFKernel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.RBFKernel) */ {
 public:
  inline RBFKernel() : RBFKernel(nullptr) {}
  ~RBFKernel() override;
  explicit constexpr RBFKernel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  RBFKernel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RBFKernel>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const RBFKernel& from);
  void MergeFrom(const RBFKernel& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kGammaFieldNumber = 1,
  };
  // double gamma = 1;
  void clear_gamma();
  double gamma() const;
  void set_gamma(double value);
  private:
  double _internal_gamma() const;
  void _internal_set_gamma(double value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.RBFKernel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double gamma_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class PolyKernel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.PolyKernel) */ {
 public:
  inline PolyKernel() : PolyKernel(nullptr) {}
  ~PolyKernel() override;
  explicit constexpr PolyKernel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  PolyKernel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PolyKernel>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PolyKernel& from);
  void MergeFrom(const PolyKernel& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kCFieldNumber = 2,
    kGammaFieldNumber = 3,
    kDegreeFieldNumber = 1,
  };
  // double c = 2;
  void clear_c();
  double c() const;
  void set_c(double value);
  private:
  double _internal_c() const;
  void _internal_set_c(double value);
  public:

  // double gamma = 3;
  void clear_gamma();
  double gamma() const;
  void set_gamma(double value);
  private:
  double _internal_gamma() const;
  void _internal_set_gamma(double value);
  public:

  // int32 degree = 1;
  void clear_degree();
  int32_t degree() const;
  void set_degree(int32_t value);
  private:
  int32_t _internal_degree() const;
  void _internal_set_degree(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.PolyKernel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double c_;
  double gamma_;
  int32_t degree_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class SigmoidKernel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.SigmoidKernel) */ {
 public:
  inline SigmoidKernel() : SigmoidKernel(nullptr) {}
  ~SigmoidKernel() override;
  explicit constexpr SigmoidKernel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  SigmoidKernel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SigmoidKernel>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SigmoidKernel& from);
  void MergeFrom(const SigmoidKernel& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kGammaFieldNumber = 1,
    kCFieldNumber = 2,
  };
  // double gamma = 1;
  void clear_gamma();
  double gamma() const;
  void set_gamma(double value);
  private:
  double _internal_gamma() const;
  void _internal_set_gamma(double value);
  public:

  // double c = 2;
  void clear_c();
  double c() const;
  void set_c(double value);
  private:
  double _internal_c() const;
  void _internal_set_c(double value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.SigmoidKernel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double gamma_;
  double c_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class Kernel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.Kernel) */ {
 public:
  inline Kernel() : Kernel(nullptr) {}
  ~Kernel() override;
  explicit constexpr Kernel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Kernel& operator=(const Kernel& from) {
    CopyFrom(from);
    return *this;
  }
  inline Kernel& operator=(Kernel&& 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 Kernel& default_instance() {
    return *internal_default_instance();
  }
  enum KernelCase {
    kLinearKernel = 1,
    kRbfKernel = 2,
    kPolyKernel = 3,
    kSigmoidKernel = 4,
    KERNEL_NOT_SET = 0,
  };

  static inline const Kernel* internal_default_instance() {
    return reinterpret_cast<const Kernel*>(
               &_Kernel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  Kernel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Kernel>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Kernel& from);
  void MergeFrom(const Kernel& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kLinearKernelFieldNumber = 1,
    kRbfKernelFieldNumber = 2,
    kPolyKernelFieldNumber = 3,
    kSigmoidKernelFieldNumber = 4,
  };
  // .CoreML.Specification.LinearKernel linearKernel = 1;
  bool has_linearkernel() const;
  private:
  bool _internal_has_linearkernel() const;
  public:
  void clear_linearkernel();
  const ::CoreML::Specification::LinearKernel& linearkernel() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::LinearKernel* release_linearkernel();
  ::CoreML::Specification::LinearKernel* mutable_linearkernel();
  void set_allocated_linearkernel(::CoreML::Specification::LinearKernel* linearkernel);
  private:
  const ::CoreML::Specification::LinearKernel& _internal_linearkernel() const;
  ::CoreML::Specification::LinearKernel* _internal_mutable_linearkernel();
  public:
  void unsafe_arena_set_allocated_linearkernel(
      ::CoreML::Specification::LinearKernel* linearkernel);
  ::CoreML::Specification::LinearKernel* unsafe_arena_release_linearkernel();

  // .CoreML.Specification.RBFKernel rbfKernel = 2;
  bool has_rbfkernel() const;
  private:
  bool _internal_has_rbfkernel() const;
  public:
  void clear_rbfkernel();
  const ::CoreML::Specification::RBFKernel& rbfkernel() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::RBFKernel* release_rbfkernel();
  ::CoreML::Specification::RBFKernel* mutable_rbfkernel();
  void set_allocated_rbfkernel(::CoreML::Specification::RBFKernel* rbfkernel);
  private:
  const ::CoreML::Specification::RBFKernel& _internal_rbfkernel() const;
  ::CoreML::Specification::RBFKernel* _internal_mutable_rbfkernel();
  public:
  void unsafe_arena_set_allocated_rbfkernel(
      ::CoreML::Specification::RBFKernel* rbfkernel);
  ::CoreML::Specification::RBFKernel* unsafe_arena_release_rbfkernel();

  // .CoreML.Specification.PolyKernel polyKernel = 3;
  bool has_polykernel() const;
  private:
  bool _internal_has_polykernel() const;
  public:
  void clear_polykernel();
  const ::CoreML::Specification::PolyKernel& polykernel() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::PolyKernel* release_polykernel();
  ::CoreML::Specification::PolyKernel* mutable_polykernel();
  void set_allocated_polykernel(::CoreML::Specification::PolyKernel* polykernel);
  private:
  const ::CoreML::Specification::PolyKernel& _internal_polykernel() const;
  ::CoreML::Specification::PolyKernel* _internal_mutable_polykernel();
  public:
  void unsafe_arena_set_allocated_polykernel(
      ::CoreML::Specification::PolyKernel* polykernel);
  ::CoreML::Specification::PolyKernel* unsafe_arena_release_polykernel();

  // .CoreML.Specification.SigmoidKernel sigmoidKernel = 4;
  bool has_sigmoidkernel() const;
  private:
  bool _internal_has_sigmoidkernel() const;
  public:
  void clear_sigmoidkernel();
  const ::CoreML::Specification::SigmoidKernel& sigmoidkernel() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::SigmoidKernel* release_sigmoidkernel();
  ::CoreML::Specification::SigmoidKernel* mutable_sigmoidkernel();
  void set_allocated_sigmoidkernel(::CoreML::Specification::SigmoidKernel* sigmoidkernel);
  private:
  const ::CoreML::Specification::SigmoidKernel& _internal_sigmoidkernel() const;
  ::CoreML::Specification::SigmoidKernel* _internal_mutable_sigmoidkernel();
  public:
  void unsafe_arena_set_allocated_sigmoidkernel(
      ::CoreML::Specification::SigmoidKernel* sigmoidkernel);
  ::CoreML::Specification::SigmoidKernel* unsafe_arena_release_sigmoidkernel();

  void clear_kernel();
  KernelCase kernel_case() const;
  // @@protoc_insertion_point(class_scope:CoreML.Specification.Kernel)
 private:
  class _Internal;
  void set_has_linearkernel();
  void set_has_rbfkernel();
  void set_has_polykernel();
  void set_has_sigmoidkernel();

  inline bool has_kernel() const;
  inline void clear_has_kernel();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union KernelUnion {
    constexpr KernelUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::CoreML::Specification::LinearKernel* linearkernel_;
    ::CoreML::Specification::RBFKernel* rbfkernel_;
    ::CoreML::Specification::PolyKernel* polykernel_;
    ::CoreML::Specification::SigmoidKernel* sigmoidkernel_;
  } kernel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class SparseNode final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.SparseNode) */ {
 public:
  inline SparseNode() : SparseNode(nullptr) {}
  ~SparseNode() override;
  explicit constexpr SparseNode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  SparseNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SparseNode>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SparseNode& from);
  void MergeFrom(const SparseNode& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kValueFieldNumber = 2,
    kIndexFieldNumber = 1,
  };
  // double value = 2;
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:

  // int32 index = 1;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.SparseNode)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double value_;
  int32_t index_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class SparseVector final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.SparseVector) */ {
 public:
  inline SparseVector() : SparseVector(nullptr) {}
  ~SparseVector() override;
  explicit constexpr SparseVector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  SparseVector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SparseVector>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SparseVector& from);
  void MergeFrom(const SparseVector& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNodesFieldNumber = 1,
  };
  // repeated .CoreML.Specification.SparseNode nodes = 1;
  int nodes_size() const;
  private:
  int _internal_nodes_size() const;
  public:
  void clear_nodes();
  ::CoreML::Specification::SparseNode* mutable_nodes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseNode >*
      mutable_nodes();
  private:
  const ::CoreML::Specification::SparseNode& _internal_nodes(int index) const;
  ::CoreML::Specification::SparseNode* _internal_add_nodes();
  public:
  const ::CoreML::Specification::SparseNode& nodes(int index) const;
  ::CoreML::Specification::SparseNode* add_nodes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseNode >&
      nodes() const;

  // @@protoc_insertion_point(class_scope:CoreML.Specification.SparseVector)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseNode > nodes_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class SparseSupportVectors final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.SparseSupportVectors) */ {
 public:
  inline SparseSupportVectors() : SparseSupportVectors(nullptr) {}
  ~SparseSupportVectors() override;
  explicit constexpr SparseSupportVectors(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  SparseSupportVectors* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SparseSupportVectors>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SparseSupportVectors& from);
  void MergeFrom(const SparseSupportVectors& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kVectorsFieldNumber = 1,
  };
  // repeated .CoreML.Specification.SparseVector vectors = 1;
  int vectors_size() const;
  private:
  int _internal_vectors_size() const;
  public:
  void clear_vectors();
  ::CoreML::Specification::SparseVector* mutable_vectors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseVector >*
      mutable_vectors();
  private:
  const ::CoreML::Specification::SparseVector& _internal_vectors(int index) const;
  ::CoreML::Specification::SparseVector* _internal_add_vectors();
  public:
  const ::CoreML::Specification::SparseVector& vectors(int index) const;
  ::CoreML::Specification::SparseVector* add_vectors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseVector >&
      vectors() const;

  // @@protoc_insertion_point(class_scope:CoreML.Specification.SparseSupportVectors)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseVector > vectors_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class DenseVector final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.DenseVector) */ {
 public:
  inline DenseVector() : DenseVector(nullptr) {}
  ~DenseVector() override;
  explicit constexpr DenseVector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  DenseVector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DenseVector>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DenseVector& from);
  void MergeFrom(const DenseVector& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kValuesFieldNumber = 1,
  };
  // repeated double values = 1;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  double _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_values() const;
  void _internal_add_values(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_values();
  public:
  double values(int index) const;
  void set_values(int index, double value);
  void add_values(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_values();

  // @@protoc_insertion_point(class_scope:CoreML.Specification.DenseVector)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > values_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class DenseSupportVectors final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.DenseSupportVectors) */ {
 public:
  inline DenseSupportVectors() : DenseSupportVectors(nullptr) {}
  ~DenseSupportVectors() override;
  explicit constexpr DenseSupportVectors(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  DenseSupportVectors* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DenseSupportVectors>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DenseSupportVectors& from);
  void MergeFrom(const DenseSupportVectors& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kVectorsFieldNumber = 1,
  };
  // repeated .CoreML.Specification.DenseVector vectors = 1;
  int vectors_size() const;
  private:
  int _internal_vectors_size() const;
  public:
  void clear_vectors();
  ::CoreML::Specification::DenseVector* mutable_vectors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::DenseVector >*
      mutable_vectors();
  private:
  const ::CoreML::Specification::DenseVector& _internal_vectors(int index) const;
  ::CoreML::Specification::DenseVector* _internal_add_vectors();
  public:
  const ::CoreML::Specification::DenseVector& vectors(int index) const;
  ::CoreML::Specification::DenseVector* add_vectors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::DenseVector >&
      vectors() const;

  // @@protoc_insertion_point(class_scope:CoreML.Specification.DenseSupportVectors)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::DenseVector > vectors_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class Coefficients final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.Coefficients) */ {
 public:
  inline Coefficients() : Coefficients(nullptr) {}
  ~Coefficients() override;
  explicit constexpr Coefficients(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

  Coefficients* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Coefficients>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Coefficients& from);
  void MergeFrom(const Coefficients& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kAlphaFieldNumber = 1,
  };
  // repeated double alpha = 1;
  int alpha_size() const;
  private:
  int _internal_alpha_size() const;
  public:
  void clear_alpha();
  private:
  double _internal_alpha(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_alpha() const;
  void _internal_add_alpha(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_alpha();
  public:
  double alpha(int index) const;
  void set_alpha(int index, double value);
  void add_alpha(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      alpha() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_alpha();

  // @@protoc_insertion_point(class_scope:CoreML.Specification.Coefficients)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > alpha_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class SupportVectorRegressor final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.SupportVectorRegressor) */ {
 public:
  inline SupportVectorRegressor() : SupportVectorRegressor(nullptr) {}
  ~SupportVectorRegressor() override;
  explicit constexpr SupportVectorRegressor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SupportVectorRegressor& operator=(const SupportVectorRegressor& from) {
    CopyFrom(from);
    return *this;
  }
  inline SupportVectorRegressor& operator=(SupportVectorRegressor&& 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 SupportVectorRegressor& default_instance() {
    return *internal_default_instance();
  }
  enum SupportVectorsCase {
    kSparseSupportVectors = 2,
    kDenseSupportVectors = 3,
    SUPPORTVECTORS_NOT_SET = 0,
  };

  static inline const SupportVectorRegressor* internal_default_instance() {
    return reinterpret_cast<const SupportVectorRegressor*>(
               &_SupportVectorRegressor_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

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

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

  SupportVectorRegressor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SupportVectorRegressor>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SupportVectorRegressor& from);
  void MergeFrom(const SupportVectorRegressor& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kKernelFieldNumber = 1,
    kCoefficientsFieldNumber = 4,
    kRhoFieldNumber = 5,
    kSparseSupportVectorsFieldNumber = 2,
    kDenseSupportVectorsFieldNumber = 3,
  };
  // .CoreML.Specification.Kernel kernel = 1;
  bool has_kernel() const;
  private:
  bool _internal_has_kernel() const;
  public:
  void clear_kernel();
  const ::CoreML::Specification::Kernel& kernel() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::Kernel* release_kernel();
  ::CoreML::Specification::Kernel* mutable_kernel();
  void set_allocated_kernel(::CoreML::Specification::Kernel* kernel);
  private:
  const ::CoreML::Specification::Kernel& _internal_kernel() const;
  ::CoreML::Specification::Kernel* _internal_mutable_kernel();
  public:
  void unsafe_arena_set_allocated_kernel(
      ::CoreML::Specification::Kernel* kernel);
  ::CoreML::Specification::Kernel* unsafe_arena_release_kernel();

  // .CoreML.Specification.Coefficients coefficients = 4;
  bool has_coefficients() const;
  private:
  bool _internal_has_coefficients() const;
  public:
  void clear_coefficients();
  const ::CoreML::Specification::Coefficients& coefficients() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::Coefficients* release_coefficients();
  ::CoreML::Specification::Coefficients* mutable_coefficients();
  void set_allocated_coefficients(::CoreML::Specification::Coefficients* coefficients);
  private:
  const ::CoreML::Specification::Coefficients& _internal_coefficients() const;
  ::CoreML::Specification::Coefficients* _internal_mutable_coefficients();
  public:
  void unsafe_arena_set_allocated_coefficients(
      ::CoreML::Specification::Coefficients* coefficients);
  ::CoreML::Specification::Coefficients* unsafe_arena_release_coefficients();

  // double rho = 5;
  void clear_rho();
  double rho() const;
  void set_rho(double value);
  private:
  double _internal_rho() const;
  void _internal_set_rho(double value);
  public:

  // .CoreML.Specification.SparseSupportVectors sparseSupportVectors = 2;
  bool has_sparsesupportvectors() const;
  private:
  bool _internal_has_sparsesupportvectors() const;
  public:
  void clear_sparsesupportvectors();
  const ::CoreML::Specification::SparseSupportVectors& sparsesupportvectors() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::SparseSupportVectors* release_sparsesupportvectors();
  ::CoreML::Specification::SparseSupportVectors* mutable_sparsesupportvectors();
  void set_allocated_sparsesupportvectors(::CoreML::Specification::SparseSupportVectors* sparsesupportvectors);
  private:
  const ::CoreML::Specification::SparseSupportVectors& _internal_sparsesupportvectors() const;
  ::CoreML::Specification::SparseSupportVectors* _internal_mutable_sparsesupportvectors();
  public:
  void unsafe_arena_set_allocated_sparsesupportvectors(
      ::CoreML::Specification::SparseSupportVectors* sparsesupportvectors);
  ::CoreML::Specification::SparseSupportVectors* unsafe_arena_release_sparsesupportvectors();

  // .CoreML.Specification.DenseSupportVectors denseSupportVectors = 3;
  bool has_densesupportvectors() const;
  private:
  bool _internal_has_densesupportvectors() const;
  public:
  void clear_densesupportvectors();
  const ::CoreML::Specification::DenseSupportVectors& densesupportvectors() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::DenseSupportVectors* release_densesupportvectors();
  ::CoreML::Specification::DenseSupportVectors* mutable_densesupportvectors();
  void set_allocated_densesupportvectors(::CoreML::Specification::DenseSupportVectors* densesupportvectors);
  private:
  const ::CoreML::Specification::DenseSupportVectors& _internal_densesupportvectors() const;
  ::CoreML::Specification::DenseSupportVectors* _internal_mutable_densesupportvectors();
  public:
  void unsafe_arena_set_allocated_densesupportvectors(
      ::CoreML::Specification::DenseSupportVectors* densesupportvectors);
  ::CoreML::Specification::DenseSupportVectors* unsafe_arena_release_densesupportvectors();

  void clear_supportVectors();
  SupportVectorsCase supportVectors_case() const;
  // @@protoc_insertion_point(class_scope:CoreML.Specification.SupportVectorRegressor)
 private:
  class _Internal;
  void set_has_sparsesupportvectors();
  void set_has_densesupportvectors();

  inline bool has_supportVectors() const;
  inline void clear_has_supportVectors();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::CoreML::Specification::Kernel* kernel_;
  ::CoreML::Specification::Coefficients* coefficients_;
  double rho_;
  union SupportVectorsUnion {
    constexpr SupportVectorsUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::CoreML::Specification::SparseSupportVectors* sparsesupportvectors_;
    ::CoreML::Specification::DenseSupportVectors* densesupportvectors_;
  } supportVectors_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_SVM_2eproto;
};
// -------------------------------------------------------------------

class SupportVectorClassifier final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:CoreML.Specification.SupportVectorClassifier) */ {
 public:
  inline SupportVectorClassifier() : SupportVectorClassifier(nullptr) {}
  ~SupportVectorClassifier() override;
  explicit constexpr SupportVectorClassifier(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SupportVectorClassifier& operator=(const SupportVectorClassifier& from) {
    CopyFrom(from);
    return *this;
  }
  inline SupportVectorClassifier& operator=(SupportVectorClassifier&& 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 SupportVectorClassifier& default_instance() {
    return *internal_default_instance();
  }
  enum SupportVectorsCase {
    kSparseSupportVectors = 3,
    kDenseSupportVectors = 4,
    SUPPORTVECTORS_NOT_SET = 0,
  };

  enum ClassLabelsCase {
    kStringClassLabels = 100,
    kInt64ClassLabels = 101,
    CLASSLABELS_NOT_SET = 0,
  };

  static inline const SupportVectorClassifier* internal_default_instance() {
    return reinterpret_cast<const SupportVectorClassifier*>(
               &_SupportVectorClassifier_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

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

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

  SupportVectorClassifier* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SupportVectorClassifier>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SupportVectorClassifier& from);
  void MergeFrom(const SupportVectorClassifier& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNumberOfSupportVectorsPerClassFieldNumber = 2,
    kCoefficientsFieldNumber = 5,
    kRhoFieldNumber = 6,
    kProbAFieldNumber = 7,
    kProbBFieldNumber = 8,
    kKernelFieldNumber = 1,
    kSparseSupportVectorsFieldNumber = 3,
    kDenseSupportVectorsFieldNumber = 4,
    kStringClassLabelsFieldNumber = 100,
    kInt64ClassLabelsFieldNumber = 101,
  };
  // repeated int32 numberOfSupportVectorsPerClass = 2;
  int numberofsupportvectorsperclass_size() const;
  private:
  int _internal_numberofsupportvectorsperclass_size() const;
  public:
  void clear_numberofsupportvectorsperclass();
  private:
  int32_t _internal_numberofsupportvectorsperclass(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_numberofsupportvectorsperclass() const;
  void _internal_add_numberofsupportvectorsperclass(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_numberofsupportvectorsperclass();
  public:
  int32_t numberofsupportvectorsperclass(int index) const;
  void set_numberofsupportvectorsperclass(int index, int32_t value);
  void add_numberofsupportvectorsperclass(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      numberofsupportvectorsperclass() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_numberofsupportvectorsperclass();

  // repeated .CoreML.Specification.Coefficients coefficients = 5;
  int coefficients_size() const;
  private:
  int _internal_coefficients_size() const;
  public:
  void clear_coefficients();
  ::CoreML::Specification::Coefficients* mutable_coefficients(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::Coefficients >*
      mutable_coefficients();
  private:
  const ::CoreML::Specification::Coefficients& _internal_coefficients(int index) const;
  ::CoreML::Specification::Coefficients* _internal_add_coefficients();
  public:
  const ::CoreML::Specification::Coefficients& coefficients(int index) const;
  ::CoreML::Specification::Coefficients* add_coefficients();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::Coefficients >&
      coefficients() const;

  // repeated double rho = 6;
  int rho_size() const;
  private:
  int _internal_rho_size() const;
  public:
  void clear_rho();
  private:
  double _internal_rho(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_rho() const;
  void _internal_add_rho(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_rho();
  public:
  double rho(int index) const;
  void set_rho(int index, double value);
  void add_rho(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      rho() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_rho();

  // repeated double probA = 7;
  int proba_size() const;
  private:
  int _internal_proba_size() const;
  public:
  void clear_proba();
  private:
  double _internal_proba(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_proba() const;
  void _internal_add_proba(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_proba();
  public:
  double proba(int index) const;
  void set_proba(int index, double value);
  void add_proba(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      proba() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_proba();

  // repeated double probB = 8;
  int probb_size() const;
  private:
  int _internal_probb_size() const;
  public:
  void clear_probb();
  private:
  double _internal_probb(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_probb() const;
  void _internal_add_probb(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_probb();
  public:
  double probb(int index) const;
  void set_probb(int index, double value);
  void add_probb(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      probb() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_probb();

  // .CoreML.Specification.Kernel kernel = 1;
  bool has_kernel() const;
  private:
  bool _internal_has_kernel() const;
  public:
  void clear_kernel();
  const ::CoreML::Specification::Kernel& kernel() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::Kernel* release_kernel();
  ::CoreML::Specification::Kernel* mutable_kernel();
  void set_allocated_kernel(::CoreML::Specification::Kernel* kernel);
  private:
  const ::CoreML::Specification::Kernel& _internal_kernel() const;
  ::CoreML::Specification::Kernel* _internal_mutable_kernel();
  public:
  void unsafe_arena_set_allocated_kernel(
      ::CoreML::Specification::Kernel* kernel);
  ::CoreML::Specification::Kernel* unsafe_arena_release_kernel();

  // .CoreML.Specification.SparseSupportVectors sparseSupportVectors = 3;
  bool has_sparsesupportvectors() const;
  private:
  bool _internal_has_sparsesupportvectors() const;
  public:
  void clear_sparsesupportvectors();
  const ::CoreML::Specification::SparseSupportVectors& sparsesupportvectors() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::SparseSupportVectors* release_sparsesupportvectors();
  ::CoreML::Specification::SparseSupportVectors* mutable_sparsesupportvectors();
  void set_allocated_sparsesupportvectors(::CoreML::Specification::SparseSupportVectors* sparsesupportvectors);
  private:
  const ::CoreML::Specification::SparseSupportVectors& _internal_sparsesupportvectors() const;
  ::CoreML::Specification::SparseSupportVectors* _internal_mutable_sparsesupportvectors();
  public:
  void unsafe_arena_set_allocated_sparsesupportvectors(
      ::CoreML::Specification::SparseSupportVectors* sparsesupportvectors);
  ::CoreML::Specification::SparseSupportVectors* unsafe_arena_release_sparsesupportvectors();

  // .CoreML.Specification.DenseSupportVectors denseSupportVectors = 4;
  bool has_densesupportvectors() const;
  private:
  bool _internal_has_densesupportvectors() const;
  public:
  void clear_densesupportvectors();
  const ::CoreML::Specification::DenseSupportVectors& densesupportvectors() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::DenseSupportVectors* release_densesupportvectors();
  ::CoreML::Specification::DenseSupportVectors* mutable_densesupportvectors();
  void set_allocated_densesupportvectors(::CoreML::Specification::DenseSupportVectors* densesupportvectors);
  private:
  const ::CoreML::Specification::DenseSupportVectors& _internal_densesupportvectors() const;
  ::CoreML::Specification::DenseSupportVectors* _internal_mutable_densesupportvectors();
  public:
  void unsafe_arena_set_allocated_densesupportvectors(
      ::CoreML::Specification::DenseSupportVectors* densesupportvectors);
  ::CoreML::Specification::DenseSupportVectors* unsafe_arena_release_densesupportvectors();

  // .CoreML.Specification.StringVector stringClassLabels = 100;
  bool has_stringclasslabels() const;
  private:
  bool _internal_has_stringclasslabels() const;
  public:
  void clear_stringclasslabels();
  const ::CoreML::Specification::StringVector& stringclasslabels() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::StringVector* release_stringclasslabels();
  ::CoreML::Specification::StringVector* mutable_stringclasslabels();
  void set_allocated_stringclasslabels(::CoreML::Specification::StringVector* stringclasslabels);
  private:
  const ::CoreML::Specification::StringVector& _internal_stringclasslabels() const;
  ::CoreML::Specification::StringVector* _internal_mutable_stringclasslabels();
  public:
  void unsafe_arena_set_allocated_stringclasslabels(
      ::CoreML::Specification::StringVector* stringclasslabels);
  ::CoreML::Specification::StringVector* unsafe_arena_release_stringclasslabels();

  // .CoreML.Specification.Int64Vector int64ClassLabels = 101;
  bool has_int64classlabels() const;
  private:
  bool _internal_has_int64classlabels() const;
  public:
  void clear_int64classlabels();
  const ::CoreML::Specification::Int64Vector& int64classlabels() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::Int64Vector* release_int64classlabels();
  ::CoreML::Specification::Int64Vector* mutable_int64classlabels();
  void set_allocated_int64classlabels(::CoreML::Specification::Int64Vector* int64classlabels);
  private:
  const ::CoreML::Specification::Int64Vector& _internal_int64classlabels() const;
  ::CoreML::Specification::Int64Vector* _internal_mutable_int64classlabels();
  public:
  void unsafe_arena_set_allocated_int64classlabels(
      ::CoreML::Specification::Int64Vector* int64classlabels);
  ::CoreML::Specification::Int64Vector* unsafe_arena_release_int64classlabels();

  void clear_supportVectors();
  SupportVectorsCase supportVectors_case() const;
  void clear_ClassLabels();
  ClassLabelsCase ClassLabels_case() const;
  // @@protoc_insertion_point(class_scope:CoreML.Specification.SupportVectorClassifier)
 private:
  class _Internal;
  void set_has_sparsesupportvectors();
  void set_has_densesupportvectors();
  void set_has_stringclasslabels();
  void set_has_int64classlabels();

  inline bool has_supportVectors() const;
  inline void clear_has_supportVectors();

  inline bool has_ClassLabels() const;
  inline void clear_has_ClassLabels();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > numberofsupportvectorsperclass_;
  mutable std::atomic<int> _numberofsupportvectorsperclass_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::Coefficients > coefficients_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > rho_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > proba_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > probb_;
  ::CoreML::Specification::Kernel* kernel_;
  union SupportVectorsUnion {
    constexpr SupportVectorsUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::CoreML::Specification::SparseSupportVectors* sparsesupportvectors_;
    ::CoreML::Specification::DenseSupportVectors* densesupportvectors_;
  } supportVectors_;
  union ClassLabelsUnion {
    constexpr ClassLabelsUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::CoreML::Specification::StringVector* stringclasslabels_;
    ::CoreML::Specification::Int64Vector* int64classlabels_;
  } ClassLabels_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[2];

  friend struct ::TableStruct_SVM_2eproto;
};
// ===================================================================


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

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

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

// RBFKernel

// double gamma = 1;
inline void RBFKernel::clear_gamma() {
  gamma_ = 0;
}
inline double RBFKernel::_internal_gamma() const {
  return gamma_;
}
inline double RBFKernel::gamma() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.RBFKernel.gamma)
  return _internal_gamma();
}
inline void RBFKernel::_internal_set_gamma(double value) {
  
  gamma_ = value;
}
inline void RBFKernel::set_gamma(double value) {
  _internal_set_gamma(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.RBFKernel.gamma)
}

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

// PolyKernel

// int32 degree = 1;
inline void PolyKernel::clear_degree() {
  degree_ = 0;
}
inline int32_t PolyKernel::_internal_degree() const {
  return degree_;
}
inline int32_t PolyKernel::degree() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.PolyKernel.degree)
  return _internal_degree();
}
inline void PolyKernel::_internal_set_degree(int32_t value) {
  
  degree_ = value;
}
inline void PolyKernel::set_degree(int32_t value) {
  _internal_set_degree(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.PolyKernel.degree)
}

// double c = 2;
inline void PolyKernel::clear_c() {
  c_ = 0;
}
inline double PolyKernel::_internal_c() const {
  return c_;
}
inline double PolyKernel::c() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.PolyKernel.c)
  return _internal_c();
}
inline void PolyKernel::_internal_set_c(double value) {
  
  c_ = value;
}
inline void PolyKernel::set_c(double value) {
  _internal_set_c(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.PolyKernel.c)
}

// double gamma = 3;
inline void PolyKernel::clear_gamma() {
  gamma_ = 0;
}
inline double PolyKernel::_internal_gamma() const {
  return gamma_;
}
inline double PolyKernel::gamma() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.PolyKernel.gamma)
  return _internal_gamma();
}
inline void PolyKernel::_internal_set_gamma(double value) {
  
  gamma_ = value;
}
inline void PolyKernel::set_gamma(double value) {
  _internal_set_gamma(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.PolyKernel.gamma)
}

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

// SigmoidKernel

// double gamma = 1;
inline void SigmoidKernel::clear_gamma() {
  gamma_ = 0;
}
inline double SigmoidKernel::_internal_gamma() const {
  return gamma_;
}
inline double SigmoidKernel::gamma() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SigmoidKernel.gamma)
  return _internal_gamma();
}
inline void SigmoidKernel::_internal_set_gamma(double value) {
  
  gamma_ = value;
}
inline void SigmoidKernel::set_gamma(double value) {
  _internal_set_gamma(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SigmoidKernel.gamma)
}

// double c = 2;
inline void SigmoidKernel::clear_c() {
  c_ = 0;
}
inline double SigmoidKernel::_internal_c() const {
  return c_;
}
inline double SigmoidKernel::c() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SigmoidKernel.c)
  return _internal_c();
}
inline void SigmoidKernel::_internal_set_c(double value) {
  
  c_ = value;
}
inline void SigmoidKernel::set_c(double value) {
  _internal_set_c(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SigmoidKernel.c)
}

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

// Kernel

// .CoreML.Specification.LinearKernel linearKernel = 1;
inline bool Kernel::_internal_has_linearkernel() const {
  return kernel_case() == kLinearKernel;
}
inline bool Kernel::has_linearkernel() const {
  return _internal_has_linearkernel();
}
inline void Kernel::set_has_linearkernel() {
  _oneof_case_[0] = kLinearKernel;
}
inline void Kernel::clear_linearkernel() {
  if (_internal_has_linearkernel()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kernel_.linearkernel_;
    }
    clear_has_kernel();
  }
}
inline ::CoreML::Specification::LinearKernel* Kernel::release_linearkernel() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.Kernel.linearKernel)
  if (_internal_has_linearkernel()) {
    clear_has_kernel();
      ::CoreML::Specification::LinearKernel* temp = kernel_.linearkernel_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kernel_.linearkernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::LinearKernel& Kernel::_internal_linearkernel() const {
  return _internal_has_linearkernel()
      ? *kernel_.linearkernel_
      : reinterpret_cast< ::CoreML::Specification::LinearKernel&>(::CoreML::Specification::_LinearKernel_default_instance_);
}
inline const ::CoreML::Specification::LinearKernel& Kernel::linearkernel() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.Kernel.linearKernel)
  return _internal_linearkernel();
}
inline ::CoreML::Specification::LinearKernel* Kernel::unsafe_arena_release_linearkernel() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.Kernel.linearKernel)
  if (_internal_has_linearkernel()) {
    clear_has_kernel();
    ::CoreML::Specification::LinearKernel* temp = kernel_.linearkernel_;
    kernel_.linearkernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Kernel::unsafe_arena_set_allocated_linearkernel(::CoreML::Specification::LinearKernel* linearkernel) {
  clear_kernel();
  if (linearkernel) {
    set_has_linearkernel();
    kernel_.linearkernel_ = linearkernel;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.Kernel.linearKernel)
}
inline ::CoreML::Specification::LinearKernel* Kernel::_internal_mutable_linearkernel() {
  if (!_internal_has_linearkernel()) {
    clear_kernel();
    set_has_linearkernel();
    kernel_.linearkernel_ = CreateMaybeMessage< ::CoreML::Specification::LinearKernel >(GetArenaForAllocation());
  }
  return kernel_.linearkernel_;
}
inline ::CoreML::Specification::LinearKernel* Kernel::mutable_linearkernel() {
  ::CoreML::Specification::LinearKernel* _msg = _internal_mutable_linearkernel();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.Kernel.linearKernel)
  return _msg;
}

// .CoreML.Specification.RBFKernel rbfKernel = 2;
inline bool Kernel::_internal_has_rbfkernel() const {
  return kernel_case() == kRbfKernel;
}
inline bool Kernel::has_rbfkernel() const {
  return _internal_has_rbfkernel();
}
inline void Kernel::set_has_rbfkernel() {
  _oneof_case_[0] = kRbfKernel;
}
inline void Kernel::clear_rbfkernel() {
  if (_internal_has_rbfkernel()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kernel_.rbfkernel_;
    }
    clear_has_kernel();
  }
}
inline ::CoreML::Specification::RBFKernel* Kernel::release_rbfkernel() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.Kernel.rbfKernel)
  if (_internal_has_rbfkernel()) {
    clear_has_kernel();
      ::CoreML::Specification::RBFKernel* temp = kernel_.rbfkernel_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kernel_.rbfkernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::RBFKernel& Kernel::_internal_rbfkernel() const {
  return _internal_has_rbfkernel()
      ? *kernel_.rbfkernel_
      : reinterpret_cast< ::CoreML::Specification::RBFKernel&>(::CoreML::Specification::_RBFKernel_default_instance_);
}
inline const ::CoreML::Specification::RBFKernel& Kernel::rbfkernel() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.Kernel.rbfKernel)
  return _internal_rbfkernel();
}
inline ::CoreML::Specification::RBFKernel* Kernel::unsafe_arena_release_rbfkernel() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.Kernel.rbfKernel)
  if (_internal_has_rbfkernel()) {
    clear_has_kernel();
    ::CoreML::Specification::RBFKernel* temp = kernel_.rbfkernel_;
    kernel_.rbfkernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Kernel::unsafe_arena_set_allocated_rbfkernel(::CoreML::Specification::RBFKernel* rbfkernel) {
  clear_kernel();
  if (rbfkernel) {
    set_has_rbfkernel();
    kernel_.rbfkernel_ = rbfkernel;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.Kernel.rbfKernel)
}
inline ::CoreML::Specification::RBFKernel* Kernel::_internal_mutable_rbfkernel() {
  if (!_internal_has_rbfkernel()) {
    clear_kernel();
    set_has_rbfkernel();
    kernel_.rbfkernel_ = CreateMaybeMessage< ::CoreML::Specification::RBFKernel >(GetArenaForAllocation());
  }
  return kernel_.rbfkernel_;
}
inline ::CoreML::Specification::RBFKernel* Kernel::mutable_rbfkernel() {
  ::CoreML::Specification::RBFKernel* _msg = _internal_mutable_rbfkernel();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.Kernel.rbfKernel)
  return _msg;
}

// .CoreML.Specification.PolyKernel polyKernel = 3;
inline bool Kernel::_internal_has_polykernel() const {
  return kernel_case() == kPolyKernel;
}
inline bool Kernel::has_polykernel() const {
  return _internal_has_polykernel();
}
inline void Kernel::set_has_polykernel() {
  _oneof_case_[0] = kPolyKernel;
}
inline void Kernel::clear_polykernel() {
  if (_internal_has_polykernel()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kernel_.polykernel_;
    }
    clear_has_kernel();
  }
}
inline ::CoreML::Specification::PolyKernel* Kernel::release_polykernel() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.Kernel.polyKernel)
  if (_internal_has_polykernel()) {
    clear_has_kernel();
      ::CoreML::Specification::PolyKernel* temp = kernel_.polykernel_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kernel_.polykernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::PolyKernel& Kernel::_internal_polykernel() const {
  return _internal_has_polykernel()
      ? *kernel_.polykernel_
      : reinterpret_cast< ::CoreML::Specification::PolyKernel&>(::CoreML::Specification::_PolyKernel_default_instance_);
}
inline const ::CoreML::Specification::PolyKernel& Kernel::polykernel() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.Kernel.polyKernel)
  return _internal_polykernel();
}
inline ::CoreML::Specification::PolyKernel* Kernel::unsafe_arena_release_polykernel() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.Kernel.polyKernel)
  if (_internal_has_polykernel()) {
    clear_has_kernel();
    ::CoreML::Specification::PolyKernel* temp = kernel_.polykernel_;
    kernel_.polykernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Kernel::unsafe_arena_set_allocated_polykernel(::CoreML::Specification::PolyKernel* polykernel) {
  clear_kernel();
  if (polykernel) {
    set_has_polykernel();
    kernel_.polykernel_ = polykernel;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.Kernel.polyKernel)
}
inline ::CoreML::Specification::PolyKernel* Kernel::_internal_mutable_polykernel() {
  if (!_internal_has_polykernel()) {
    clear_kernel();
    set_has_polykernel();
    kernel_.polykernel_ = CreateMaybeMessage< ::CoreML::Specification::PolyKernel >(GetArenaForAllocation());
  }
  return kernel_.polykernel_;
}
inline ::CoreML::Specification::PolyKernel* Kernel::mutable_polykernel() {
  ::CoreML::Specification::PolyKernel* _msg = _internal_mutable_polykernel();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.Kernel.polyKernel)
  return _msg;
}

// .CoreML.Specification.SigmoidKernel sigmoidKernel = 4;
inline bool Kernel::_internal_has_sigmoidkernel() const {
  return kernel_case() == kSigmoidKernel;
}
inline bool Kernel::has_sigmoidkernel() const {
  return _internal_has_sigmoidkernel();
}
inline void Kernel::set_has_sigmoidkernel() {
  _oneof_case_[0] = kSigmoidKernel;
}
inline void Kernel::clear_sigmoidkernel() {
  if (_internal_has_sigmoidkernel()) {
    if (GetArenaForAllocation() == nullptr) {
      delete kernel_.sigmoidkernel_;
    }
    clear_has_kernel();
  }
}
inline ::CoreML::Specification::SigmoidKernel* Kernel::release_sigmoidkernel() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.Kernel.sigmoidKernel)
  if (_internal_has_sigmoidkernel()) {
    clear_has_kernel();
      ::CoreML::Specification::SigmoidKernel* temp = kernel_.sigmoidkernel_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    kernel_.sigmoidkernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::SigmoidKernel& Kernel::_internal_sigmoidkernel() const {
  return _internal_has_sigmoidkernel()
      ? *kernel_.sigmoidkernel_
      : reinterpret_cast< ::CoreML::Specification::SigmoidKernel&>(::CoreML::Specification::_SigmoidKernel_default_instance_);
}
inline const ::CoreML::Specification::SigmoidKernel& Kernel::sigmoidkernel() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.Kernel.sigmoidKernel)
  return _internal_sigmoidkernel();
}
inline ::CoreML::Specification::SigmoidKernel* Kernel::unsafe_arena_release_sigmoidkernel() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.Kernel.sigmoidKernel)
  if (_internal_has_sigmoidkernel()) {
    clear_has_kernel();
    ::CoreML::Specification::SigmoidKernel* temp = kernel_.sigmoidkernel_;
    kernel_.sigmoidkernel_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Kernel::unsafe_arena_set_allocated_sigmoidkernel(::CoreML::Specification::SigmoidKernel* sigmoidkernel) {
  clear_kernel();
  if (sigmoidkernel) {
    set_has_sigmoidkernel();
    kernel_.sigmoidkernel_ = sigmoidkernel;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.Kernel.sigmoidKernel)
}
inline ::CoreML::Specification::SigmoidKernel* Kernel::_internal_mutable_sigmoidkernel() {
  if (!_internal_has_sigmoidkernel()) {
    clear_kernel();
    set_has_sigmoidkernel();
    kernel_.sigmoidkernel_ = CreateMaybeMessage< ::CoreML::Specification::SigmoidKernel >(GetArenaForAllocation());
  }
  return kernel_.sigmoidkernel_;
}
inline ::CoreML::Specification::SigmoidKernel* Kernel::mutable_sigmoidkernel() {
  ::CoreML::Specification::SigmoidKernel* _msg = _internal_mutable_sigmoidkernel();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.Kernel.sigmoidKernel)
  return _msg;
}

inline bool Kernel::has_kernel() const {
  return kernel_case() != KERNEL_NOT_SET;
}
inline void Kernel::clear_has_kernel() {
  _oneof_case_[0] = KERNEL_NOT_SET;
}
inline Kernel::KernelCase Kernel::kernel_case() const {
  return Kernel::KernelCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// SparseNode

// int32 index = 1;
inline void SparseNode::clear_index() {
  index_ = 0;
}
inline int32_t SparseNode::_internal_index() const {
  return index_;
}
inline int32_t SparseNode::index() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SparseNode.index)
  return _internal_index();
}
inline void SparseNode::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void SparseNode::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SparseNode.index)
}

// double value = 2;
inline void SparseNode::clear_value() {
  value_ = 0;
}
inline double SparseNode::_internal_value() const {
  return value_;
}
inline double SparseNode::value() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SparseNode.value)
  return _internal_value();
}
inline void SparseNode::_internal_set_value(double value) {
  
  value_ = value;
}
inline void SparseNode::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SparseNode.value)
}

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

// SparseVector

// repeated .CoreML.Specification.SparseNode nodes = 1;
inline int SparseVector::_internal_nodes_size() const {
  return nodes_.size();
}
inline int SparseVector::nodes_size() const {
  return _internal_nodes_size();
}
inline void SparseVector::clear_nodes() {
  nodes_.Clear();
}
inline ::CoreML::Specification::SparseNode* SparseVector::mutable_nodes(int index) {
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SparseVector.nodes)
  return nodes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseNode >*
SparseVector::mutable_nodes() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SparseVector.nodes)
  return &nodes_;
}
inline const ::CoreML::Specification::SparseNode& SparseVector::_internal_nodes(int index) const {
  return nodes_.Get(index);
}
inline const ::CoreML::Specification::SparseNode& SparseVector::nodes(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SparseVector.nodes)
  return _internal_nodes(index);
}
inline ::CoreML::Specification::SparseNode* SparseVector::_internal_add_nodes() {
  return nodes_.Add();
}
inline ::CoreML::Specification::SparseNode* SparseVector::add_nodes() {
  ::CoreML::Specification::SparseNode* _add = _internal_add_nodes();
  // @@protoc_insertion_point(field_add:CoreML.Specification.SparseVector.nodes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseNode >&
SparseVector::nodes() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SparseVector.nodes)
  return nodes_;
}

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

// SparseSupportVectors

// repeated .CoreML.Specification.SparseVector vectors = 1;
inline int SparseSupportVectors::_internal_vectors_size() const {
  return vectors_.size();
}
inline int SparseSupportVectors::vectors_size() const {
  return _internal_vectors_size();
}
inline void SparseSupportVectors::clear_vectors() {
  vectors_.Clear();
}
inline ::CoreML::Specification::SparseVector* SparseSupportVectors::mutable_vectors(int index) {
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SparseSupportVectors.vectors)
  return vectors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseVector >*
SparseSupportVectors::mutable_vectors() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SparseSupportVectors.vectors)
  return &vectors_;
}
inline const ::CoreML::Specification::SparseVector& SparseSupportVectors::_internal_vectors(int index) const {
  return vectors_.Get(index);
}
inline const ::CoreML::Specification::SparseVector& SparseSupportVectors::vectors(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SparseSupportVectors.vectors)
  return _internal_vectors(index);
}
inline ::CoreML::Specification::SparseVector* SparseSupportVectors::_internal_add_vectors() {
  return vectors_.Add();
}
inline ::CoreML::Specification::SparseVector* SparseSupportVectors::add_vectors() {
  ::CoreML::Specification::SparseVector* _add = _internal_add_vectors();
  // @@protoc_insertion_point(field_add:CoreML.Specification.SparseSupportVectors.vectors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::SparseVector >&
SparseSupportVectors::vectors() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SparseSupportVectors.vectors)
  return vectors_;
}

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

// DenseVector

// repeated double values = 1;
inline int DenseVector::_internal_values_size() const {
  return values_.size();
}
inline int DenseVector::values_size() const {
  return _internal_values_size();
}
inline void DenseVector::clear_values() {
  values_.Clear();
}
inline double DenseVector::_internal_values(int index) const {
  return values_.Get(index);
}
inline double DenseVector::values(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.DenseVector.values)
  return _internal_values(index);
}
inline void DenseVector::set_values(int index, double value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.DenseVector.values)
}
inline void DenseVector::_internal_add_values(double value) {
  values_.Add(value);
}
inline void DenseVector::add_values(double value) {
  _internal_add_values(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.DenseVector.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DenseVector::_internal_values() const {
  return values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DenseVector::values() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.DenseVector.values)
  return _internal_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DenseVector::_internal_mutable_values() {
  return &values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DenseVector::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.DenseVector.values)
  return _internal_mutable_values();
}

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

// DenseSupportVectors

// repeated .CoreML.Specification.DenseVector vectors = 1;
inline int DenseSupportVectors::_internal_vectors_size() const {
  return vectors_.size();
}
inline int DenseSupportVectors::vectors_size() const {
  return _internal_vectors_size();
}
inline void DenseSupportVectors::clear_vectors() {
  vectors_.Clear();
}
inline ::CoreML::Specification::DenseVector* DenseSupportVectors::mutable_vectors(int index) {
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.DenseSupportVectors.vectors)
  return vectors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::DenseVector >*
DenseSupportVectors::mutable_vectors() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.DenseSupportVectors.vectors)
  return &vectors_;
}
inline const ::CoreML::Specification::DenseVector& DenseSupportVectors::_internal_vectors(int index) const {
  return vectors_.Get(index);
}
inline const ::CoreML::Specification::DenseVector& DenseSupportVectors::vectors(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.DenseSupportVectors.vectors)
  return _internal_vectors(index);
}
inline ::CoreML::Specification::DenseVector* DenseSupportVectors::_internal_add_vectors() {
  return vectors_.Add();
}
inline ::CoreML::Specification::DenseVector* DenseSupportVectors::add_vectors() {
  ::CoreML::Specification::DenseVector* _add = _internal_add_vectors();
  // @@protoc_insertion_point(field_add:CoreML.Specification.DenseSupportVectors.vectors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::DenseVector >&
DenseSupportVectors::vectors() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.DenseSupportVectors.vectors)
  return vectors_;
}

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

// Coefficients

// repeated double alpha = 1;
inline int Coefficients::_internal_alpha_size() const {
  return alpha_.size();
}
inline int Coefficients::alpha_size() const {
  return _internal_alpha_size();
}
inline void Coefficients::clear_alpha() {
  alpha_.Clear();
}
inline double Coefficients::_internal_alpha(int index) const {
  return alpha_.Get(index);
}
inline double Coefficients::alpha(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.Coefficients.alpha)
  return _internal_alpha(index);
}
inline void Coefficients::set_alpha(int index, double value) {
  alpha_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.Coefficients.alpha)
}
inline void Coefficients::_internal_add_alpha(double value) {
  alpha_.Add(value);
}
inline void Coefficients::add_alpha(double value) {
  _internal_add_alpha(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.Coefficients.alpha)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Coefficients::_internal_alpha() const {
  return alpha_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Coefficients::alpha() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.Coefficients.alpha)
  return _internal_alpha();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Coefficients::_internal_mutable_alpha() {
  return &alpha_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Coefficients::mutable_alpha() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.Coefficients.alpha)
  return _internal_mutable_alpha();
}

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

// SupportVectorRegressor

// .CoreML.Specification.Kernel kernel = 1;
inline bool SupportVectorRegressor::_internal_has_kernel() const {
  return this != internal_default_instance() && kernel_ != nullptr;
}
inline bool SupportVectorRegressor::has_kernel() const {
  return _internal_has_kernel();
}
inline void SupportVectorRegressor::clear_kernel() {
  if (GetArenaForAllocation() == nullptr && kernel_ != nullptr) {
    delete kernel_;
  }
  kernel_ = nullptr;
}
inline const ::CoreML::Specification::Kernel& SupportVectorRegressor::_internal_kernel() const {
  const ::CoreML::Specification::Kernel* p = kernel_;
  return p != nullptr ? *p : reinterpret_cast<const ::CoreML::Specification::Kernel&>(
      ::CoreML::Specification::_Kernel_default_instance_);
}
inline const ::CoreML::Specification::Kernel& SupportVectorRegressor::kernel() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorRegressor.kernel)
  return _internal_kernel();
}
inline void SupportVectorRegressor::unsafe_arena_set_allocated_kernel(
    ::CoreML::Specification::Kernel* kernel) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(kernel_);
  }
  kernel_ = kernel;
  if (kernel) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorRegressor.kernel)
}
inline ::CoreML::Specification::Kernel* SupportVectorRegressor::release_kernel() {
  
  ::CoreML::Specification::Kernel* temp = kernel_;
  kernel_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CoreML::Specification::Kernel* SupportVectorRegressor::unsafe_arena_release_kernel() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorRegressor.kernel)
  
  ::CoreML::Specification::Kernel* temp = kernel_;
  kernel_ = nullptr;
  return temp;
}
inline ::CoreML::Specification::Kernel* SupportVectorRegressor::_internal_mutable_kernel() {
  
  if (kernel_ == nullptr) {
    auto* p = CreateMaybeMessage<::CoreML::Specification::Kernel>(GetArenaForAllocation());
    kernel_ = p;
  }
  return kernel_;
}
inline ::CoreML::Specification::Kernel* SupportVectorRegressor::mutable_kernel() {
  ::CoreML::Specification::Kernel* _msg = _internal_mutable_kernel();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorRegressor.kernel)
  return _msg;
}
inline void SupportVectorRegressor::set_allocated_kernel(::CoreML::Specification::Kernel* kernel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete kernel_;
  }
  if (kernel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::Kernel>::GetOwningArena(kernel);
    if (message_arena != submessage_arena) {
      kernel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, kernel, submessage_arena);
    }
    
  } else {
    
  }
  kernel_ = kernel;
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.SupportVectorRegressor.kernel)
}

// .CoreML.Specification.SparseSupportVectors sparseSupportVectors = 2;
inline bool SupportVectorRegressor::_internal_has_sparsesupportvectors() const {
  return supportVectors_case() == kSparseSupportVectors;
}
inline bool SupportVectorRegressor::has_sparsesupportvectors() const {
  return _internal_has_sparsesupportvectors();
}
inline void SupportVectorRegressor::set_has_sparsesupportvectors() {
  _oneof_case_[0] = kSparseSupportVectors;
}
inline void SupportVectorRegressor::clear_sparsesupportvectors() {
  if (_internal_has_sparsesupportvectors()) {
    if (GetArenaForAllocation() == nullptr) {
      delete supportVectors_.sparsesupportvectors_;
    }
    clear_has_supportVectors();
  }
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorRegressor::release_sparsesupportvectors() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorRegressor.sparseSupportVectors)
  if (_internal_has_sparsesupportvectors()) {
    clear_has_supportVectors();
      ::CoreML::Specification::SparseSupportVectors* temp = supportVectors_.sparsesupportvectors_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    supportVectors_.sparsesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::SparseSupportVectors& SupportVectorRegressor::_internal_sparsesupportvectors() const {
  return _internal_has_sparsesupportvectors()
      ? *supportVectors_.sparsesupportvectors_
      : reinterpret_cast< ::CoreML::Specification::SparseSupportVectors&>(::CoreML::Specification::_SparseSupportVectors_default_instance_);
}
inline const ::CoreML::Specification::SparseSupportVectors& SupportVectorRegressor::sparsesupportvectors() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorRegressor.sparseSupportVectors)
  return _internal_sparsesupportvectors();
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorRegressor::unsafe_arena_release_sparsesupportvectors() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.SupportVectorRegressor.sparseSupportVectors)
  if (_internal_has_sparsesupportvectors()) {
    clear_has_supportVectors();
    ::CoreML::Specification::SparseSupportVectors* temp = supportVectors_.sparsesupportvectors_;
    supportVectors_.sparsesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SupportVectorRegressor::unsafe_arena_set_allocated_sparsesupportvectors(::CoreML::Specification::SparseSupportVectors* sparsesupportvectors) {
  clear_supportVectors();
  if (sparsesupportvectors) {
    set_has_sparsesupportvectors();
    supportVectors_.sparsesupportvectors_ = sparsesupportvectors;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorRegressor.sparseSupportVectors)
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorRegressor::_internal_mutable_sparsesupportvectors() {
  if (!_internal_has_sparsesupportvectors()) {
    clear_supportVectors();
    set_has_sparsesupportvectors();
    supportVectors_.sparsesupportvectors_ = CreateMaybeMessage< ::CoreML::Specification::SparseSupportVectors >(GetArenaForAllocation());
  }
  return supportVectors_.sparsesupportvectors_;
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorRegressor::mutable_sparsesupportvectors() {
  ::CoreML::Specification::SparseSupportVectors* _msg = _internal_mutable_sparsesupportvectors();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorRegressor.sparseSupportVectors)
  return _msg;
}

// .CoreML.Specification.DenseSupportVectors denseSupportVectors = 3;
inline bool SupportVectorRegressor::_internal_has_densesupportvectors() const {
  return supportVectors_case() == kDenseSupportVectors;
}
inline bool SupportVectorRegressor::has_densesupportvectors() const {
  return _internal_has_densesupportvectors();
}
inline void SupportVectorRegressor::set_has_densesupportvectors() {
  _oneof_case_[0] = kDenseSupportVectors;
}
inline void SupportVectorRegressor::clear_densesupportvectors() {
  if (_internal_has_densesupportvectors()) {
    if (GetArenaForAllocation() == nullptr) {
      delete supportVectors_.densesupportvectors_;
    }
    clear_has_supportVectors();
  }
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorRegressor::release_densesupportvectors() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorRegressor.denseSupportVectors)
  if (_internal_has_densesupportvectors()) {
    clear_has_supportVectors();
      ::CoreML::Specification::DenseSupportVectors* temp = supportVectors_.densesupportvectors_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    supportVectors_.densesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::DenseSupportVectors& SupportVectorRegressor::_internal_densesupportvectors() const {
  return _internal_has_densesupportvectors()
      ? *supportVectors_.densesupportvectors_
      : reinterpret_cast< ::CoreML::Specification::DenseSupportVectors&>(::CoreML::Specification::_DenseSupportVectors_default_instance_);
}
inline const ::CoreML::Specification::DenseSupportVectors& SupportVectorRegressor::densesupportvectors() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorRegressor.denseSupportVectors)
  return _internal_densesupportvectors();
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorRegressor::unsafe_arena_release_densesupportvectors() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.SupportVectorRegressor.denseSupportVectors)
  if (_internal_has_densesupportvectors()) {
    clear_has_supportVectors();
    ::CoreML::Specification::DenseSupportVectors* temp = supportVectors_.densesupportvectors_;
    supportVectors_.densesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SupportVectorRegressor::unsafe_arena_set_allocated_densesupportvectors(::CoreML::Specification::DenseSupportVectors* densesupportvectors) {
  clear_supportVectors();
  if (densesupportvectors) {
    set_has_densesupportvectors();
    supportVectors_.densesupportvectors_ = densesupportvectors;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorRegressor.denseSupportVectors)
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorRegressor::_internal_mutable_densesupportvectors() {
  if (!_internal_has_densesupportvectors()) {
    clear_supportVectors();
    set_has_densesupportvectors();
    supportVectors_.densesupportvectors_ = CreateMaybeMessage< ::CoreML::Specification::DenseSupportVectors >(GetArenaForAllocation());
  }
  return supportVectors_.densesupportvectors_;
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorRegressor::mutable_densesupportvectors() {
  ::CoreML::Specification::DenseSupportVectors* _msg = _internal_mutable_densesupportvectors();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorRegressor.denseSupportVectors)
  return _msg;
}

// .CoreML.Specification.Coefficients coefficients = 4;
inline bool SupportVectorRegressor::_internal_has_coefficients() const {
  return this != internal_default_instance() && coefficients_ != nullptr;
}
inline bool SupportVectorRegressor::has_coefficients() const {
  return _internal_has_coefficients();
}
inline void SupportVectorRegressor::clear_coefficients() {
  if (GetArenaForAllocation() == nullptr && coefficients_ != nullptr) {
    delete coefficients_;
  }
  coefficients_ = nullptr;
}
inline const ::CoreML::Specification::Coefficients& SupportVectorRegressor::_internal_coefficients() const {
  const ::CoreML::Specification::Coefficients* p = coefficients_;
  return p != nullptr ? *p : reinterpret_cast<const ::CoreML::Specification::Coefficients&>(
      ::CoreML::Specification::_Coefficients_default_instance_);
}
inline const ::CoreML::Specification::Coefficients& SupportVectorRegressor::coefficients() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorRegressor.coefficients)
  return _internal_coefficients();
}
inline void SupportVectorRegressor::unsafe_arena_set_allocated_coefficients(
    ::CoreML::Specification::Coefficients* coefficients) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(coefficients_);
  }
  coefficients_ = coefficients;
  if (coefficients) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorRegressor.coefficients)
}
inline ::CoreML::Specification::Coefficients* SupportVectorRegressor::release_coefficients() {
  
  ::CoreML::Specification::Coefficients* temp = coefficients_;
  coefficients_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CoreML::Specification::Coefficients* SupportVectorRegressor::unsafe_arena_release_coefficients() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorRegressor.coefficients)
  
  ::CoreML::Specification::Coefficients* temp = coefficients_;
  coefficients_ = nullptr;
  return temp;
}
inline ::CoreML::Specification::Coefficients* SupportVectorRegressor::_internal_mutable_coefficients() {
  
  if (coefficients_ == nullptr) {
    auto* p = CreateMaybeMessage<::CoreML::Specification::Coefficients>(GetArenaForAllocation());
    coefficients_ = p;
  }
  return coefficients_;
}
inline ::CoreML::Specification::Coefficients* SupportVectorRegressor::mutable_coefficients() {
  ::CoreML::Specification::Coefficients* _msg = _internal_mutable_coefficients();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorRegressor.coefficients)
  return _msg;
}
inline void SupportVectorRegressor::set_allocated_coefficients(::CoreML::Specification::Coefficients* coefficients) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete coefficients_;
  }
  if (coefficients) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::Coefficients>::GetOwningArena(coefficients);
    if (message_arena != submessage_arena) {
      coefficients = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, coefficients, submessage_arena);
    }
    
  } else {
    
  }
  coefficients_ = coefficients;
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.SupportVectorRegressor.coefficients)
}

// double rho = 5;
inline void SupportVectorRegressor::clear_rho() {
  rho_ = 0;
}
inline double SupportVectorRegressor::_internal_rho() const {
  return rho_;
}
inline double SupportVectorRegressor::rho() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorRegressor.rho)
  return _internal_rho();
}
inline void SupportVectorRegressor::_internal_set_rho(double value) {
  
  rho_ = value;
}
inline void SupportVectorRegressor::set_rho(double value) {
  _internal_set_rho(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SupportVectorRegressor.rho)
}

inline bool SupportVectorRegressor::has_supportVectors() const {
  return supportVectors_case() != SUPPORTVECTORS_NOT_SET;
}
inline void SupportVectorRegressor::clear_has_supportVectors() {
  _oneof_case_[0] = SUPPORTVECTORS_NOT_SET;
}
inline SupportVectorRegressor::SupportVectorsCase SupportVectorRegressor::supportVectors_case() const {
  return SupportVectorRegressor::SupportVectorsCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// SupportVectorClassifier

// .CoreML.Specification.Kernel kernel = 1;
inline bool SupportVectorClassifier::_internal_has_kernel() const {
  return this != internal_default_instance() && kernel_ != nullptr;
}
inline bool SupportVectorClassifier::has_kernel() const {
  return _internal_has_kernel();
}
inline void SupportVectorClassifier::clear_kernel() {
  if (GetArenaForAllocation() == nullptr && kernel_ != nullptr) {
    delete kernel_;
  }
  kernel_ = nullptr;
}
inline const ::CoreML::Specification::Kernel& SupportVectorClassifier::_internal_kernel() const {
  const ::CoreML::Specification::Kernel* p = kernel_;
  return p != nullptr ? *p : reinterpret_cast<const ::CoreML::Specification::Kernel&>(
      ::CoreML::Specification::_Kernel_default_instance_);
}
inline const ::CoreML::Specification::Kernel& SupportVectorClassifier::kernel() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.kernel)
  return _internal_kernel();
}
inline void SupportVectorClassifier::unsafe_arena_set_allocated_kernel(
    ::CoreML::Specification::Kernel* kernel) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(kernel_);
  }
  kernel_ = kernel;
  if (kernel) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorClassifier.kernel)
}
inline ::CoreML::Specification::Kernel* SupportVectorClassifier::release_kernel() {
  
  ::CoreML::Specification::Kernel* temp = kernel_;
  kernel_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CoreML::Specification::Kernel* SupportVectorClassifier::unsafe_arena_release_kernel() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorClassifier.kernel)
  
  ::CoreML::Specification::Kernel* temp = kernel_;
  kernel_ = nullptr;
  return temp;
}
inline ::CoreML::Specification::Kernel* SupportVectorClassifier::_internal_mutable_kernel() {
  
  if (kernel_ == nullptr) {
    auto* p = CreateMaybeMessage<::CoreML::Specification::Kernel>(GetArenaForAllocation());
    kernel_ = p;
  }
  return kernel_;
}
inline ::CoreML::Specification::Kernel* SupportVectorClassifier::mutable_kernel() {
  ::CoreML::Specification::Kernel* _msg = _internal_mutable_kernel();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorClassifier.kernel)
  return _msg;
}
inline void SupportVectorClassifier::set_allocated_kernel(::CoreML::Specification::Kernel* kernel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete kernel_;
  }
  if (kernel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::Kernel>::GetOwningArena(kernel);
    if (message_arena != submessage_arena) {
      kernel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, kernel, submessage_arena);
    }
    
  } else {
    
  }
  kernel_ = kernel;
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.SupportVectorClassifier.kernel)
}

// repeated int32 numberOfSupportVectorsPerClass = 2;
inline int SupportVectorClassifier::_internal_numberofsupportvectorsperclass_size() const {
  return numberofsupportvectorsperclass_.size();
}
inline int SupportVectorClassifier::numberofsupportvectorsperclass_size() const {
  return _internal_numberofsupportvectorsperclass_size();
}
inline void SupportVectorClassifier::clear_numberofsupportvectorsperclass() {
  numberofsupportvectorsperclass_.Clear();
}
inline int32_t SupportVectorClassifier::_internal_numberofsupportvectorsperclass(int index) const {
  return numberofsupportvectorsperclass_.Get(index);
}
inline int32_t SupportVectorClassifier::numberofsupportvectorsperclass(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.numberOfSupportVectorsPerClass)
  return _internal_numberofsupportvectorsperclass(index);
}
inline void SupportVectorClassifier::set_numberofsupportvectorsperclass(int index, int32_t value) {
  numberofsupportvectorsperclass_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SupportVectorClassifier.numberOfSupportVectorsPerClass)
}
inline void SupportVectorClassifier::_internal_add_numberofsupportvectorsperclass(int32_t value) {
  numberofsupportvectorsperclass_.Add(value);
}
inline void SupportVectorClassifier::add_numberofsupportvectorsperclass(int32_t value) {
  _internal_add_numberofsupportvectorsperclass(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.SupportVectorClassifier.numberOfSupportVectorsPerClass)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SupportVectorClassifier::_internal_numberofsupportvectorsperclass() const {
  return numberofsupportvectorsperclass_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SupportVectorClassifier::numberofsupportvectorsperclass() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SupportVectorClassifier.numberOfSupportVectorsPerClass)
  return _internal_numberofsupportvectorsperclass();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SupportVectorClassifier::_internal_mutable_numberofsupportvectorsperclass() {
  return &numberofsupportvectorsperclass_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SupportVectorClassifier::mutable_numberofsupportvectorsperclass() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SupportVectorClassifier.numberOfSupportVectorsPerClass)
  return _internal_mutable_numberofsupportvectorsperclass();
}

// .CoreML.Specification.SparseSupportVectors sparseSupportVectors = 3;
inline bool SupportVectorClassifier::_internal_has_sparsesupportvectors() const {
  return supportVectors_case() == kSparseSupportVectors;
}
inline bool SupportVectorClassifier::has_sparsesupportvectors() const {
  return _internal_has_sparsesupportvectors();
}
inline void SupportVectorClassifier::set_has_sparsesupportvectors() {
  _oneof_case_[0] = kSparseSupportVectors;
}
inline void SupportVectorClassifier::clear_sparsesupportvectors() {
  if (_internal_has_sparsesupportvectors()) {
    if (GetArenaForAllocation() == nullptr) {
      delete supportVectors_.sparsesupportvectors_;
    }
    clear_has_supportVectors();
  }
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorClassifier::release_sparsesupportvectors() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorClassifier.sparseSupportVectors)
  if (_internal_has_sparsesupportvectors()) {
    clear_has_supportVectors();
      ::CoreML::Specification::SparseSupportVectors* temp = supportVectors_.sparsesupportvectors_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    supportVectors_.sparsesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::SparseSupportVectors& SupportVectorClassifier::_internal_sparsesupportvectors() const {
  return _internal_has_sparsesupportvectors()
      ? *supportVectors_.sparsesupportvectors_
      : reinterpret_cast< ::CoreML::Specification::SparseSupportVectors&>(::CoreML::Specification::_SparseSupportVectors_default_instance_);
}
inline const ::CoreML::Specification::SparseSupportVectors& SupportVectorClassifier::sparsesupportvectors() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.sparseSupportVectors)
  return _internal_sparsesupportvectors();
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorClassifier::unsafe_arena_release_sparsesupportvectors() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.SupportVectorClassifier.sparseSupportVectors)
  if (_internal_has_sparsesupportvectors()) {
    clear_has_supportVectors();
    ::CoreML::Specification::SparseSupportVectors* temp = supportVectors_.sparsesupportvectors_;
    supportVectors_.sparsesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SupportVectorClassifier::unsafe_arena_set_allocated_sparsesupportvectors(::CoreML::Specification::SparseSupportVectors* sparsesupportvectors) {
  clear_supportVectors();
  if (sparsesupportvectors) {
    set_has_sparsesupportvectors();
    supportVectors_.sparsesupportvectors_ = sparsesupportvectors;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorClassifier.sparseSupportVectors)
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorClassifier::_internal_mutable_sparsesupportvectors() {
  if (!_internal_has_sparsesupportvectors()) {
    clear_supportVectors();
    set_has_sparsesupportvectors();
    supportVectors_.sparsesupportvectors_ = CreateMaybeMessage< ::CoreML::Specification::SparseSupportVectors >(GetArenaForAllocation());
  }
  return supportVectors_.sparsesupportvectors_;
}
inline ::CoreML::Specification::SparseSupportVectors* SupportVectorClassifier::mutable_sparsesupportvectors() {
  ::CoreML::Specification::SparseSupportVectors* _msg = _internal_mutable_sparsesupportvectors();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorClassifier.sparseSupportVectors)
  return _msg;
}

// .CoreML.Specification.DenseSupportVectors denseSupportVectors = 4;
inline bool SupportVectorClassifier::_internal_has_densesupportvectors() const {
  return supportVectors_case() == kDenseSupportVectors;
}
inline bool SupportVectorClassifier::has_densesupportvectors() const {
  return _internal_has_densesupportvectors();
}
inline void SupportVectorClassifier::set_has_densesupportvectors() {
  _oneof_case_[0] = kDenseSupportVectors;
}
inline void SupportVectorClassifier::clear_densesupportvectors() {
  if (_internal_has_densesupportvectors()) {
    if (GetArenaForAllocation() == nullptr) {
      delete supportVectors_.densesupportvectors_;
    }
    clear_has_supportVectors();
  }
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorClassifier::release_densesupportvectors() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorClassifier.denseSupportVectors)
  if (_internal_has_densesupportvectors()) {
    clear_has_supportVectors();
      ::CoreML::Specification::DenseSupportVectors* temp = supportVectors_.densesupportvectors_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    supportVectors_.densesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::DenseSupportVectors& SupportVectorClassifier::_internal_densesupportvectors() const {
  return _internal_has_densesupportvectors()
      ? *supportVectors_.densesupportvectors_
      : reinterpret_cast< ::CoreML::Specification::DenseSupportVectors&>(::CoreML::Specification::_DenseSupportVectors_default_instance_);
}
inline const ::CoreML::Specification::DenseSupportVectors& SupportVectorClassifier::densesupportvectors() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.denseSupportVectors)
  return _internal_densesupportvectors();
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorClassifier::unsafe_arena_release_densesupportvectors() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.SupportVectorClassifier.denseSupportVectors)
  if (_internal_has_densesupportvectors()) {
    clear_has_supportVectors();
    ::CoreML::Specification::DenseSupportVectors* temp = supportVectors_.densesupportvectors_;
    supportVectors_.densesupportvectors_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SupportVectorClassifier::unsafe_arena_set_allocated_densesupportvectors(::CoreML::Specification::DenseSupportVectors* densesupportvectors) {
  clear_supportVectors();
  if (densesupportvectors) {
    set_has_densesupportvectors();
    supportVectors_.densesupportvectors_ = densesupportvectors;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorClassifier.denseSupportVectors)
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorClassifier::_internal_mutable_densesupportvectors() {
  if (!_internal_has_densesupportvectors()) {
    clear_supportVectors();
    set_has_densesupportvectors();
    supportVectors_.densesupportvectors_ = CreateMaybeMessage< ::CoreML::Specification::DenseSupportVectors >(GetArenaForAllocation());
  }
  return supportVectors_.densesupportvectors_;
}
inline ::CoreML::Specification::DenseSupportVectors* SupportVectorClassifier::mutable_densesupportvectors() {
  ::CoreML::Specification::DenseSupportVectors* _msg = _internal_mutable_densesupportvectors();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorClassifier.denseSupportVectors)
  return _msg;
}

// repeated .CoreML.Specification.Coefficients coefficients = 5;
inline int SupportVectorClassifier::_internal_coefficients_size() const {
  return coefficients_.size();
}
inline int SupportVectorClassifier::coefficients_size() const {
  return _internal_coefficients_size();
}
inline void SupportVectorClassifier::clear_coefficients() {
  coefficients_.Clear();
}
inline ::CoreML::Specification::Coefficients* SupportVectorClassifier::mutable_coefficients(int index) {
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorClassifier.coefficients)
  return coefficients_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::Coefficients >*
SupportVectorClassifier::mutable_coefficients() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SupportVectorClassifier.coefficients)
  return &coefficients_;
}
inline const ::CoreML::Specification::Coefficients& SupportVectorClassifier::_internal_coefficients(int index) const {
  return coefficients_.Get(index);
}
inline const ::CoreML::Specification::Coefficients& SupportVectorClassifier::coefficients(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.coefficients)
  return _internal_coefficients(index);
}
inline ::CoreML::Specification::Coefficients* SupportVectorClassifier::_internal_add_coefficients() {
  return coefficients_.Add();
}
inline ::CoreML::Specification::Coefficients* SupportVectorClassifier::add_coefficients() {
  ::CoreML::Specification::Coefficients* _add = _internal_add_coefficients();
  // @@protoc_insertion_point(field_add:CoreML.Specification.SupportVectorClassifier.coefficients)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::Coefficients >&
SupportVectorClassifier::coefficients() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SupportVectorClassifier.coefficients)
  return coefficients_;
}

// repeated double rho = 6;
inline int SupportVectorClassifier::_internal_rho_size() const {
  return rho_.size();
}
inline int SupportVectorClassifier::rho_size() const {
  return _internal_rho_size();
}
inline void SupportVectorClassifier::clear_rho() {
  rho_.Clear();
}
inline double SupportVectorClassifier::_internal_rho(int index) const {
  return rho_.Get(index);
}
inline double SupportVectorClassifier::rho(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.rho)
  return _internal_rho(index);
}
inline void SupportVectorClassifier::set_rho(int index, double value) {
  rho_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SupportVectorClassifier.rho)
}
inline void SupportVectorClassifier::_internal_add_rho(double value) {
  rho_.Add(value);
}
inline void SupportVectorClassifier::add_rho(double value) {
  _internal_add_rho(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.SupportVectorClassifier.rho)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SupportVectorClassifier::_internal_rho() const {
  return rho_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SupportVectorClassifier::rho() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SupportVectorClassifier.rho)
  return _internal_rho();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SupportVectorClassifier::_internal_mutable_rho() {
  return &rho_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SupportVectorClassifier::mutable_rho() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SupportVectorClassifier.rho)
  return _internal_mutable_rho();
}

// repeated double probA = 7;
inline int SupportVectorClassifier::_internal_proba_size() const {
  return proba_.size();
}
inline int SupportVectorClassifier::proba_size() const {
  return _internal_proba_size();
}
inline void SupportVectorClassifier::clear_proba() {
  proba_.Clear();
}
inline double SupportVectorClassifier::_internal_proba(int index) const {
  return proba_.Get(index);
}
inline double SupportVectorClassifier::proba(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.probA)
  return _internal_proba(index);
}
inline void SupportVectorClassifier::set_proba(int index, double value) {
  proba_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SupportVectorClassifier.probA)
}
inline void SupportVectorClassifier::_internal_add_proba(double value) {
  proba_.Add(value);
}
inline void SupportVectorClassifier::add_proba(double value) {
  _internal_add_proba(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.SupportVectorClassifier.probA)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SupportVectorClassifier::_internal_proba() const {
  return proba_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SupportVectorClassifier::proba() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SupportVectorClassifier.probA)
  return _internal_proba();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SupportVectorClassifier::_internal_mutable_proba() {
  return &proba_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SupportVectorClassifier::mutable_proba() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SupportVectorClassifier.probA)
  return _internal_mutable_proba();
}

// repeated double probB = 8;
inline int SupportVectorClassifier::_internal_probb_size() const {
  return probb_.size();
}
inline int SupportVectorClassifier::probb_size() const {
  return _internal_probb_size();
}
inline void SupportVectorClassifier::clear_probb() {
  probb_.Clear();
}
inline double SupportVectorClassifier::_internal_probb(int index) const {
  return probb_.Get(index);
}
inline double SupportVectorClassifier::probb(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.probB)
  return _internal_probb(index);
}
inline void SupportVectorClassifier::set_probb(int index, double value) {
  probb_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.SupportVectorClassifier.probB)
}
inline void SupportVectorClassifier::_internal_add_probb(double value) {
  probb_.Add(value);
}
inline void SupportVectorClassifier::add_probb(double value) {
  _internal_add_probb(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.SupportVectorClassifier.probB)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SupportVectorClassifier::_internal_probb() const {
  return probb_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SupportVectorClassifier::probb() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.SupportVectorClassifier.probB)
  return _internal_probb();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SupportVectorClassifier::_internal_mutable_probb() {
  return &probb_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SupportVectorClassifier::mutable_probb() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.SupportVectorClassifier.probB)
  return _internal_mutable_probb();
}

// .CoreML.Specification.StringVector stringClassLabels = 100;
inline bool SupportVectorClassifier::_internal_has_stringclasslabels() const {
  return ClassLabels_case() == kStringClassLabels;
}
inline bool SupportVectorClassifier::has_stringclasslabels() const {
  return _internal_has_stringclasslabels();
}
inline void SupportVectorClassifier::set_has_stringclasslabels() {
  _oneof_case_[1] = kStringClassLabels;
}
inline ::CoreML::Specification::StringVector* SupportVectorClassifier::release_stringclasslabels() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorClassifier.stringClassLabels)
  if (_internal_has_stringclasslabels()) {
    clear_has_ClassLabels();
      ::CoreML::Specification::StringVector* temp = ClassLabels_.stringclasslabels_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    ClassLabels_.stringclasslabels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::StringVector& SupportVectorClassifier::_internal_stringclasslabels() const {
  return _internal_has_stringclasslabels()
      ? *ClassLabels_.stringclasslabels_
      : reinterpret_cast< ::CoreML::Specification::StringVector&>(::CoreML::Specification::_StringVector_default_instance_);
}
inline const ::CoreML::Specification::StringVector& SupportVectorClassifier::stringclasslabels() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.stringClassLabels)
  return _internal_stringclasslabels();
}
inline ::CoreML::Specification::StringVector* SupportVectorClassifier::unsafe_arena_release_stringclasslabels() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.SupportVectorClassifier.stringClassLabels)
  if (_internal_has_stringclasslabels()) {
    clear_has_ClassLabels();
    ::CoreML::Specification::StringVector* temp = ClassLabels_.stringclasslabels_;
    ClassLabels_.stringclasslabels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SupportVectorClassifier::unsafe_arena_set_allocated_stringclasslabels(::CoreML::Specification::StringVector* stringclasslabels) {
  clear_ClassLabels();
  if (stringclasslabels) {
    set_has_stringclasslabels();
    ClassLabels_.stringclasslabels_ = stringclasslabels;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorClassifier.stringClassLabels)
}
inline ::CoreML::Specification::StringVector* SupportVectorClassifier::_internal_mutable_stringclasslabels() {
  if (!_internal_has_stringclasslabels()) {
    clear_ClassLabels();
    set_has_stringclasslabels();
    ClassLabels_.stringclasslabels_ = CreateMaybeMessage< ::CoreML::Specification::StringVector >(GetArenaForAllocation());
  }
  return ClassLabels_.stringclasslabels_;
}
inline ::CoreML::Specification::StringVector* SupportVectorClassifier::mutable_stringclasslabels() {
  ::CoreML::Specification::StringVector* _msg = _internal_mutable_stringclasslabels();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorClassifier.stringClassLabels)
  return _msg;
}

// .CoreML.Specification.Int64Vector int64ClassLabels = 101;
inline bool SupportVectorClassifier::_internal_has_int64classlabels() const {
  return ClassLabels_case() == kInt64ClassLabels;
}
inline bool SupportVectorClassifier::has_int64classlabels() const {
  return _internal_has_int64classlabels();
}
inline void SupportVectorClassifier::set_has_int64classlabels() {
  _oneof_case_[1] = kInt64ClassLabels;
}
inline ::CoreML::Specification::Int64Vector* SupportVectorClassifier::release_int64classlabels() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.SupportVectorClassifier.int64ClassLabels)
  if (_internal_has_int64classlabels()) {
    clear_has_ClassLabels();
      ::CoreML::Specification::Int64Vector* temp = ClassLabels_.int64classlabels_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    ClassLabels_.int64classlabels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::CoreML::Specification::Int64Vector& SupportVectorClassifier::_internal_int64classlabels() const {
  return _internal_has_int64classlabels()
      ? *ClassLabels_.int64classlabels_
      : reinterpret_cast< ::CoreML::Specification::Int64Vector&>(::CoreML::Specification::_Int64Vector_default_instance_);
}
inline const ::CoreML::Specification::Int64Vector& SupportVectorClassifier::int64classlabels() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.SupportVectorClassifier.int64ClassLabels)
  return _internal_int64classlabels();
}
inline ::CoreML::Specification::Int64Vector* SupportVectorClassifier::unsafe_arena_release_int64classlabels() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.SupportVectorClassifier.int64ClassLabels)
  if (_internal_has_int64classlabels()) {
    clear_has_ClassLabels();
    ::CoreML::Specification::Int64Vector* temp = ClassLabels_.int64classlabels_;
    ClassLabels_.int64classlabels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SupportVectorClassifier::unsafe_arena_set_allocated_int64classlabels(::CoreML::Specification::Int64Vector* int64classlabels) {
  clear_ClassLabels();
  if (int64classlabels) {
    set_has_int64classlabels();
    ClassLabels_.int64classlabels_ = int64classlabels;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.SupportVectorClassifier.int64ClassLabels)
}
inline ::CoreML::Specification::Int64Vector* SupportVectorClassifier::_internal_mutable_int64classlabels() {
  if (!_internal_has_int64classlabels()) {
    clear_ClassLabels();
    set_has_int64classlabels();
    ClassLabels_.int64classlabels_ = CreateMaybeMessage< ::CoreML::Specification::Int64Vector >(GetArenaForAllocation());
  }
  return ClassLabels_.int64classlabels_;
}
inline ::CoreML::Specification::Int64Vector* SupportVectorClassifier::mutable_int64classlabels() {
  ::CoreML::Specification::Int64Vector* _msg = _internal_mutable_int64classlabels();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.SupportVectorClassifier.int64ClassLabels)
  return _msg;
}

inline bool SupportVectorClassifier::has_supportVectors() const {
  return supportVectors_case() != SUPPORTVECTORS_NOT_SET;
}
inline void SupportVectorClassifier::clear_has_supportVectors() {
  _oneof_case_[0] = SUPPORTVECTORS_NOT_SET;
}
inline bool SupportVectorClassifier::has_ClassLabels() const {
  return ClassLabels_case() != CLASSLABELS_NOT_SET;
}
inline void SupportVectorClassifier::clear_has_ClassLabels() {
  _oneof_case_[1] = CLASSLABELS_NOT_SET;
}
inline SupportVectorClassifier::SupportVectorsCase SupportVectorClassifier::supportVectors_case() const {
  return SupportVectorClassifier::SupportVectorsCase(_oneof_case_[0]);
}
inline SupportVectorClassifier::ClassLabelsCase SupportVectorClassifier::ClassLabels_case() const {
  return SupportVectorClassifier::ClassLabelsCase(_oneof_case_[1]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Specification
}  // namespace CoreML

// @@protoc_insertion_point(global_scope)

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