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

#ifndef GOOGLE_PROTOBUF_INCLUDED_TreeEnsemble_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_TreeEnsemble_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 <google/protobuf/generated_enum_util.h>
#include "DataStructures.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_TreeEnsemble_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_TreeEnsemble_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[5]
    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 TreeEnsembleClassifier;
struct TreeEnsembleClassifierDefaultTypeInternal;
extern TreeEnsembleClassifierDefaultTypeInternal _TreeEnsembleClassifier_default_instance_;
class TreeEnsembleParameters;
struct TreeEnsembleParametersDefaultTypeInternal;
extern TreeEnsembleParametersDefaultTypeInternal _TreeEnsembleParameters_default_instance_;
class TreeEnsembleParameters_TreeNode;
struct TreeEnsembleParameters_TreeNodeDefaultTypeInternal;
extern TreeEnsembleParameters_TreeNodeDefaultTypeInternal _TreeEnsembleParameters_TreeNode_default_instance_;
class TreeEnsembleParameters_TreeNode_EvaluationInfo;
struct TreeEnsembleParameters_TreeNode_EvaluationInfoDefaultTypeInternal;
extern TreeEnsembleParameters_TreeNode_EvaluationInfoDefaultTypeInternal _TreeEnsembleParameters_TreeNode_EvaluationInfo_default_instance_;
class TreeEnsembleRegressor;
struct TreeEnsembleRegressorDefaultTypeInternal;
extern TreeEnsembleRegressorDefaultTypeInternal _TreeEnsembleRegressor_default_instance_;
}  // namespace Specification
}  // namespace CoreML
PROTOBUF_NAMESPACE_OPEN
template<> ::CoreML::Specification::TreeEnsembleClassifier* Arena::CreateMaybeMessage<::CoreML::Specification::TreeEnsembleClassifier>(Arena*);
template<> ::CoreML::Specification::TreeEnsembleParameters* Arena::CreateMaybeMessage<::CoreML::Specification::TreeEnsembleParameters>(Arena*);
template<> ::CoreML::Specification::TreeEnsembleParameters_TreeNode* Arena::CreateMaybeMessage<::CoreML::Specification::TreeEnsembleParameters_TreeNode>(Arena*);
template<> ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* Arena::CreateMaybeMessage<::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo>(Arena*);
template<> ::CoreML::Specification::TreeEnsembleRegressor* Arena::CreateMaybeMessage<::CoreML::Specification::TreeEnsembleRegressor>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace CoreML {
namespace Specification {

enum TreeEnsembleParameters_TreeNode_TreeNodeBehavior : int {
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueLessThanEqual = 0,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueLessThan = 1,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueGreaterThanEqual = 2,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueGreaterThan = 3,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueEqual = 4,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueNotEqual = 5,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_LeafNode = 6,
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeEnsembleParameters_TreeNode_TreeNodeBehavior_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeEnsembleParameters_TreeNode_TreeNodeBehavior_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool TreeEnsembleParameters_TreeNode_TreeNodeBehavior_IsValid(int value);
constexpr TreeEnsembleParameters_TreeNode_TreeNodeBehavior TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_MIN = TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueLessThanEqual;
constexpr TreeEnsembleParameters_TreeNode_TreeNodeBehavior TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_MAX = TreeEnsembleParameters_TreeNode_TreeNodeBehavior_LeafNode;
constexpr int TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_ARRAYSIZE = TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_MAX + 1;

const std::string& TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Name(TreeEnsembleParameters_TreeNode_TreeNodeBehavior value);
template<typename T>
inline const std::string& TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TreeEnsembleParameters_TreeNode_TreeNodeBehavior>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Name.");
  return TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Name(static_cast<TreeEnsembleParameters_TreeNode_TreeNodeBehavior>(enum_t_value));
}
bool TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TreeEnsembleParameters_TreeNode_TreeNodeBehavior* value);
enum TreeEnsemblePostEvaluationTransform : int {
  NoTransform = 0,
  Classification_SoftMax = 1,
  Regression_Logistic = 2,
  Classification_SoftMaxWithZeroClassReference = 3,
  TreeEnsemblePostEvaluationTransform_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  TreeEnsemblePostEvaluationTransform_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool TreeEnsemblePostEvaluationTransform_IsValid(int value);
constexpr TreeEnsemblePostEvaluationTransform TreeEnsemblePostEvaluationTransform_MIN = NoTransform;
constexpr TreeEnsemblePostEvaluationTransform TreeEnsemblePostEvaluationTransform_MAX = Classification_SoftMaxWithZeroClassReference;
constexpr int TreeEnsemblePostEvaluationTransform_ARRAYSIZE = TreeEnsemblePostEvaluationTransform_MAX + 1;

const std::string& TreeEnsemblePostEvaluationTransform_Name(TreeEnsemblePostEvaluationTransform value);
template<typename T>
inline const std::string& TreeEnsemblePostEvaluationTransform_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TreeEnsemblePostEvaluationTransform>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TreeEnsemblePostEvaluationTransform_Name.");
  return TreeEnsemblePostEvaluationTransform_Name(static_cast<TreeEnsemblePostEvaluationTransform>(enum_t_value));
}
bool TreeEnsemblePostEvaluationTransform_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TreeEnsemblePostEvaluationTransform* value);
// ===================================================================

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

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

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

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

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

  TreeEnsembleParameters_TreeNode_EvaluationInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TreeEnsembleParameters_TreeNode_EvaluationInfo>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TreeEnsembleParameters_TreeNode_EvaluationInfo& from);
  void MergeFrom(const TreeEnsembleParameters_TreeNode_EvaluationInfo& 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(TreeEnsembleParameters_TreeNode_EvaluationInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo";
  }
  protected:
  explicit TreeEnsembleParameters_TreeNode_EvaluationInfo(::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 {
    kEvaluationIndexFieldNumber = 1,
    kEvaluationValueFieldNumber = 2,
  };
  // uint64 evaluationIndex = 1;
  void clear_evaluationindex();
  uint64_t evaluationindex() const;
  void set_evaluationindex(uint64_t value);
  private:
  uint64_t _internal_evaluationindex() const;
  void _internal_set_evaluationindex(uint64_t value);
  public:

  // double evaluationValue = 2;
  void clear_evaluationvalue();
  double evaluationvalue() const;
  void set_evaluationvalue(double value);
  private:
  double _internal_evaluationvalue() const;
  void _internal_set_evaluationvalue(double value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo)
 private:
  class _Internal;

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

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

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

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

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

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

  TreeEnsembleParameters_TreeNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TreeEnsembleParameters_TreeNode>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TreeEnsembleParameters_TreeNode& from);
  void MergeFrom(const TreeEnsembleParameters_TreeNode& 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(TreeEnsembleParameters_TreeNode* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CoreML.Specification.TreeEnsembleParameters.TreeNode";
  }
  protected:
  explicit TreeEnsembleParameters_TreeNode(::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 ----------------------------------------------------

  typedef TreeEnsembleParameters_TreeNode_EvaluationInfo EvaluationInfo;

  typedef TreeEnsembleParameters_TreeNode_TreeNodeBehavior TreeNodeBehavior;
  static constexpr TreeNodeBehavior BranchOnValueLessThanEqual =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueLessThanEqual;
  static constexpr TreeNodeBehavior BranchOnValueLessThan =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueLessThan;
  static constexpr TreeNodeBehavior BranchOnValueGreaterThanEqual =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueGreaterThanEqual;
  static constexpr TreeNodeBehavior BranchOnValueGreaterThan =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueGreaterThan;
  static constexpr TreeNodeBehavior BranchOnValueEqual =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueEqual;
  static constexpr TreeNodeBehavior BranchOnValueNotEqual =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_BranchOnValueNotEqual;
  static constexpr TreeNodeBehavior LeafNode =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_LeafNode;
  static inline bool TreeNodeBehavior_IsValid(int value) {
    return TreeEnsembleParameters_TreeNode_TreeNodeBehavior_IsValid(value);
  }
  static constexpr TreeNodeBehavior TreeNodeBehavior_MIN =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_MIN;
  static constexpr TreeNodeBehavior TreeNodeBehavior_MAX =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_MAX;
  static constexpr int TreeNodeBehavior_ARRAYSIZE =
    TreeEnsembleParameters_TreeNode_TreeNodeBehavior_TreeNodeBehavior_ARRAYSIZE;
  template<typename T>
  static inline const std::string& TreeNodeBehavior_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TreeNodeBehavior>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TreeNodeBehavior_Name.");
    return TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Name(enum_t_value);
  }
  static inline bool TreeNodeBehavior_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      TreeNodeBehavior* value) {
    return TreeEnsembleParameters_TreeNode_TreeNodeBehavior_Parse(name, value);
  }

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

  enum : int {
    kEvaluationInfoFieldNumber = 20,
    kTreeIdFieldNumber = 1,
    kNodeIdFieldNumber = 2,
    kNodeBehaviorFieldNumber = 3,
    kMissingValueTracksTrueChildFieldNumber = 14,
    kBranchFeatureIndexFieldNumber = 10,
    kBranchFeatureValueFieldNumber = 11,
    kTrueChildNodeIdFieldNumber = 12,
    kFalseChildNodeIdFieldNumber = 13,
    kRelativeHitRateFieldNumber = 30,
  };
  // repeated .CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo evaluationInfo = 20;
  int evaluationinfo_size() const;
  private:
  int _internal_evaluationinfo_size() const;
  public:
  void clear_evaluationinfo();
  ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* mutable_evaluationinfo(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo >*
      mutable_evaluationinfo();
  private:
  const ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo& _internal_evaluationinfo(int index) const;
  ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* _internal_add_evaluationinfo();
  public:
  const ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo& evaluationinfo(int index) const;
  ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* add_evaluationinfo();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo >&
      evaluationinfo() const;

  // uint64 treeId = 1;
  void clear_treeid();
  uint64_t treeid() const;
  void set_treeid(uint64_t value);
  private:
  uint64_t _internal_treeid() const;
  void _internal_set_treeid(uint64_t value);
  public:

  // uint64 nodeId = 2;
  void clear_nodeid();
  uint64_t nodeid() const;
  void set_nodeid(uint64_t value);
  private:
  uint64_t _internal_nodeid() const;
  void _internal_set_nodeid(uint64_t value);
  public:

  // .CoreML.Specification.TreeEnsembleParameters.TreeNode.TreeNodeBehavior nodeBehavior = 3;
  void clear_nodebehavior();
  ::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior nodebehavior() const;
  void set_nodebehavior(::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior value);
  private:
  ::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior _internal_nodebehavior() const;
  void _internal_set_nodebehavior(::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior value);
  public:

  // bool missingValueTracksTrueChild = 14;
  void clear_missingvaluetrackstruechild();
  bool missingvaluetrackstruechild() const;
  void set_missingvaluetrackstruechild(bool value);
  private:
  bool _internal_missingvaluetrackstruechild() const;
  void _internal_set_missingvaluetrackstruechild(bool value);
  public:

  // uint64 branchFeatureIndex = 10;
  void clear_branchfeatureindex();
  uint64_t branchfeatureindex() const;
  void set_branchfeatureindex(uint64_t value);
  private:
  uint64_t _internal_branchfeatureindex() const;
  void _internal_set_branchfeatureindex(uint64_t value);
  public:

  // double branchFeatureValue = 11;
  void clear_branchfeaturevalue();
  double branchfeaturevalue() const;
  void set_branchfeaturevalue(double value);
  private:
  double _internal_branchfeaturevalue() const;
  void _internal_set_branchfeaturevalue(double value);
  public:

  // uint64 trueChildNodeId = 12;
  void clear_truechildnodeid();
  uint64_t truechildnodeid() const;
  void set_truechildnodeid(uint64_t value);
  private:
  uint64_t _internal_truechildnodeid() const;
  void _internal_set_truechildnodeid(uint64_t value);
  public:

  // uint64 falseChildNodeId = 13;
  void clear_falsechildnodeid();
  uint64_t falsechildnodeid() const;
  void set_falsechildnodeid(uint64_t value);
  private:
  uint64_t _internal_falsechildnodeid() const;
  void _internal_set_falsechildnodeid(uint64_t value);
  public:

  // double relativeHitRate = 30;
  void clear_relativehitrate();
  double relativehitrate() const;
  void set_relativehitrate(double value);
  private:
  double _internal_relativehitrate() const;
  void _internal_set_relativehitrate(double value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.TreeEnsembleParameters.TreeNode)
 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::TreeEnsembleParameters_TreeNode_EvaluationInfo > evaluationinfo_;
  uint64_t treeid_;
  uint64_t nodeid_;
  int nodebehavior_;
  bool missingvaluetrackstruechild_;
  uint64_t branchfeatureindex_;
  double branchfeaturevalue_;
  uint64_t truechildnodeid_;
  uint64_t falsechildnodeid_;
  double relativehitrate_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_TreeEnsemble_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  TreeEnsembleParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TreeEnsembleParameters>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TreeEnsembleParameters& from);
  void MergeFrom(const TreeEnsembleParameters& 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(TreeEnsembleParameters* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CoreML.Specification.TreeEnsembleParameters";
  }
  protected:
  explicit TreeEnsembleParameters(::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 ----------------------------------------------------

  typedef TreeEnsembleParameters_TreeNode TreeNode;

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

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

  // repeated double basePredictionValue = 3;
  int basepredictionvalue_size() const;
  private:
  int _internal_basepredictionvalue_size() const;
  public:
  void clear_basepredictionvalue();
  private:
  double _internal_basepredictionvalue(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_basepredictionvalue() const;
  void _internal_add_basepredictionvalue(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_basepredictionvalue();
  public:
  double basepredictionvalue(int index) const;
  void set_basepredictionvalue(int index, double value);
  void add_basepredictionvalue(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      basepredictionvalue() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_basepredictionvalue();

  // uint64 numPredictionDimensions = 2;
  void clear_numpredictiondimensions();
  uint64_t numpredictiondimensions() const;
  void set_numpredictiondimensions(uint64_t value);
  private:
  uint64_t _internal_numpredictiondimensions() const;
  void _internal_set_numpredictiondimensions(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CoreML.Specification.TreeEnsembleParameters)
 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::TreeEnsembleParameters_TreeNode > nodes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > basepredictionvalue_;
  uint64_t numpredictiondimensions_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_TreeEnsemble_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline TreeEnsembleClassifier& operator=(const TreeEnsembleClassifier& from) {
    CopyFrom(from);
    return *this;
  }
  inline TreeEnsembleClassifier& operator=(TreeEnsembleClassifier&& 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 TreeEnsembleClassifier& default_instance() {
    return *internal_default_instance();
  }
  enum ClassLabelsCase {
    kStringClassLabels = 100,
    kInt64ClassLabels = 101,
    CLASSLABELS_NOT_SET = 0,
  };

  static inline const TreeEnsembleClassifier* internal_default_instance() {
    return reinterpret_cast<const TreeEnsembleClassifier*>(
               &_TreeEnsembleClassifier_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  TreeEnsembleClassifier* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TreeEnsembleClassifier>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TreeEnsembleClassifier& from);
  void MergeFrom(const TreeEnsembleClassifier& 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(TreeEnsembleClassifier* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CoreML.Specification.TreeEnsembleClassifier";
  }
  protected:
  explicit TreeEnsembleClassifier(::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 {
    kTreeEnsembleFieldNumber = 1,
    kPostEvaluationTransformFieldNumber = 2,
    kStringClassLabelsFieldNumber = 100,
    kInt64ClassLabelsFieldNumber = 101,
  };
  // .CoreML.Specification.TreeEnsembleParameters treeEnsemble = 1;
  bool has_treeensemble() const;
  private:
  bool _internal_has_treeensemble() const;
  public:
  void clear_treeensemble();
  const ::CoreML::Specification::TreeEnsembleParameters& treeensemble() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::TreeEnsembleParameters* release_treeensemble();
  ::CoreML::Specification::TreeEnsembleParameters* mutable_treeensemble();
  void set_allocated_treeensemble(::CoreML::Specification::TreeEnsembleParameters* treeensemble);
  private:
  const ::CoreML::Specification::TreeEnsembleParameters& _internal_treeensemble() const;
  ::CoreML::Specification::TreeEnsembleParameters* _internal_mutable_treeensemble();
  public:
  void unsafe_arena_set_allocated_treeensemble(
      ::CoreML::Specification::TreeEnsembleParameters* treeensemble);
  ::CoreML::Specification::TreeEnsembleParameters* unsafe_arena_release_treeensemble();

  // .CoreML.Specification.TreeEnsemblePostEvaluationTransform postEvaluationTransform = 2;
  void clear_postevaluationtransform();
  ::CoreML::Specification::TreeEnsemblePostEvaluationTransform postevaluationtransform() const;
  void set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value);
  private:
  ::CoreML::Specification::TreeEnsemblePostEvaluationTransform _internal_postevaluationtransform() const;
  void _internal_set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value);
  public:

  // .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_ClassLabels();
  ClassLabelsCase ClassLabels_case() const;
  // @@protoc_insertion_point(class_scope:CoreML.Specification.TreeEnsembleClassifier)
 private:
  class _Internal;
  void set_has_stringclasslabels();
  void set_has_int64classlabels();

  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_;
  ::CoreML::Specification::TreeEnsembleParameters* treeensemble_;
  int postevaluationtransform_;
  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_[1];

  friend struct ::TableStruct_TreeEnsemble_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  TreeEnsembleRegressor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TreeEnsembleRegressor>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TreeEnsembleRegressor& from);
  void MergeFrom(const TreeEnsembleRegressor& 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(TreeEnsembleRegressor* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CoreML.Specification.TreeEnsembleRegressor";
  }
  protected:
  explicit TreeEnsembleRegressor(::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 {
    kTreeEnsembleFieldNumber = 1,
    kPostEvaluationTransformFieldNumber = 2,
  };
  // .CoreML.Specification.TreeEnsembleParameters treeEnsemble = 1;
  bool has_treeensemble() const;
  private:
  bool _internal_has_treeensemble() const;
  public:
  void clear_treeensemble();
  const ::CoreML::Specification::TreeEnsembleParameters& treeensemble() const;
  PROTOBUF_NODISCARD ::CoreML::Specification::TreeEnsembleParameters* release_treeensemble();
  ::CoreML::Specification::TreeEnsembleParameters* mutable_treeensemble();
  void set_allocated_treeensemble(::CoreML::Specification::TreeEnsembleParameters* treeensemble);
  private:
  const ::CoreML::Specification::TreeEnsembleParameters& _internal_treeensemble() const;
  ::CoreML::Specification::TreeEnsembleParameters* _internal_mutable_treeensemble();
  public:
  void unsafe_arena_set_allocated_treeensemble(
      ::CoreML::Specification::TreeEnsembleParameters* treeensemble);
  ::CoreML::Specification::TreeEnsembleParameters* unsafe_arena_release_treeensemble();

  // .CoreML.Specification.TreeEnsemblePostEvaluationTransform postEvaluationTransform = 2;
  void clear_postevaluationtransform();
  ::CoreML::Specification::TreeEnsemblePostEvaluationTransform postevaluationtransform() const;
  void set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value);
  private:
  ::CoreML::Specification::TreeEnsemblePostEvaluationTransform _internal_postevaluationtransform() const;
  void _internal_set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::CoreML::Specification::TreeEnsembleParameters* treeensemble_;
  int postevaluationtransform_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_TreeEnsemble_2eproto;
};
// ===================================================================


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

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

// uint64 evaluationIndex = 1;
inline void TreeEnsembleParameters_TreeNode_EvaluationInfo::clear_evaluationindex() {
  evaluationindex_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters_TreeNode_EvaluationInfo::_internal_evaluationindex() const {
  return evaluationindex_;
}
inline uint64_t TreeEnsembleParameters_TreeNode_EvaluationInfo::evaluationindex() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo.evaluationIndex)
  return _internal_evaluationindex();
}
inline void TreeEnsembleParameters_TreeNode_EvaluationInfo::_internal_set_evaluationindex(uint64_t value) {
  
  evaluationindex_ = value;
}
inline void TreeEnsembleParameters_TreeNode_EvaluationInfo::set_evaluationindex(uint64_t value) {
  _internal_set_evaluationindex(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo.evaluationIndex)
}

// double evaluationValue = 2;
inline void TreeEnsembleParameters_TreeNode_EvaluationInfo::clear_evaluationvalue() {
  evaluationvalue_ = 0;
}
inline double TreeEnsembleParameters_TreeNode_EvaluationInfo::_internal_evaluationvalue() const {
  return evaluationvalue_;
}
inline double TreeEnsembleParameters_TreeNode_EvaluationInfo::evaluationvalue() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo.evaluationValue)
  return _internal_evaluationvalue();
}
inline void TreeEnsembleParameters_TreeNode_EvaluationInfo::_internal_set_evaluationvalue(double value) {
  
  evaluationvalue_ = value;
}
inline void TreeEnsembleParameters_TreeNode_EvaluationInfo::set_evaluationvalue(double value) {
  _internal_set_evaluationvalue(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo.evaluationValue)
}

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

// TreeEnsembleParameters_TreeNode

// uint64 treeId = 1;
inline void TreeEnsembleParameters_TreeNode::clear_treeid() {
  treeid_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters_TreeNode::_internal_treeid() const {
  return treeid_;
}
inline uint64_t TreeEnsembleParameters_TreeNode::treeid() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.treeId)
  return _internal_treeid();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_treeid(uint64_t value) {
  
  treeid_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_treeid(uint64_t value) {
  _internal_set_treeid(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.treeId)
}

// uint64 nodeId = 2;
inline void TreeEnsembleParameters_TreeNode::clear_nodeid() {
  nodeid_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters_TreeNode::_internal_nodeid() const {
  return nodeid_;
}
inline uint64_t TreeEnsembleParameters_TreeNode::nodeid() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.nodeId)
  return _internal_nodeid();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_nodeid(uint64_t value) {
  
  nodeid_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_nodeid(uint64_t value) {
  _internal_set_nodeid(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.nodeId)
}

// .CoreML.Specification.TreeEnsembleParameters.TreeNode.TreeNodeBehavior nodeBehavior = 3;
inline void TreeEnsembleParameters_TreeNode::clear_nodebehavior() {
  nodebehavior_ = 0;
}
inline ::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior TreeEnsembleParameters_TreeNode::_internal_nodebehavior() const {
  return static_cast< ::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior >(nodebehavior_);
}
inline ::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior TreeEnsembleParameters_TreeNode::nodebehavior() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.nodeBehavior)
  return _internal_nodebehavior();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_nodebehavior(::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior value) {
  
  nodebehavior_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_nodebehavior(::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior value) {
  _internal_set_nodebehavior(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.nodeBehavior)
}

// uint64 branchFeatureIndex = 10;
inline void TreeEnsembleParameters_TreeNode::clear_branchfeatureindex() {
  branchfeatureindex_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters_TreeNode::_internal_branchfeatureindex() const {
  return branchfeatureindex_;
}
inline uint64_t TreeEnsembleParameters_TreeNode::branchfeatureindex() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.branchFeatureIndex)
  return _internal_branchfeatureindex();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_branchfeatureindex(uint64_t value) {
  
  branchfeatureindex_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_branchfeatureindex(uint64_t value) {
  _internal_set_branchfeatureindex(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.branchFeatureIndex)
}

// double branchFeatureValue = 11;
inline void TreeEnsembleParameters_TreeNode::clear_branchfeaturevalue() {
  branchfeaturevalue_ = 0;
}
inline double TreeEnsembleParameters_TreeNode::_internal_branchfeaturevalue() const {
  return branchfeaturevalue_;
}
inline double TreeEnsembleParameters_TreeNode::branchfeaturevalue() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.branchFeatureValue)
  return _internal_branchfeaturevalue();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_branchfeaturevalue(double value) {
  
  branchfeaturevalue_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_branchfeaturevalue(double value) {
  _internal_set_branchfeaturevalue(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.branchFeatureValue)
}

// uint64 trueChildNodeId = 12;
inline void TreeEnsembleParameters_TreeNode::clear_truechildnodeid() {
  truechildnodeid_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters_TreeNode::_internal_truechildnodeid() const {
  return truechildnodeid_;
}
inline uint64_t TreeEnsembleParameters_TreeNode::truechildnodeid() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.trueChildNodeId)
  return _internal_truechildnodeid();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_truechildnodeid(uint64_t value) {
  
  truechildnodeid_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_truechildnodeid(uint64_t value) {
  _internal_set_truechildnodeid(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.trueChildNodeId)
}

// uint64 falseChildNodeId = 13;
inline void TreeEnsembleParameters_TreeNode::clear_falsechildnodeid() {
  falsechildnodeid_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters_TreeNode::_internal_falsechildnodeid() const {
  return falsechildnodeid_;
}
inline uint64_t TreeEnsembleParameters_TreeNode::falsechildnodeid() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.falseChildNodeId)
  return _internal_falsechildnodeid();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_falsechildnodeid(uint64_t value) {
  
  falsechildnodeid_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_falsechildnodeid(uint64_t value) {
  _internal_set_falsechildnodeid(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.falseChildNodeId)
}

// bool missingValueTracksTrueChild = 14;
inline void TreeEnsembleParameters_TreeNode::clear_missingvaluetrackstruechild() {
  missingvaluetrackstruechild_ = false;
}
inline bool TreeEnsembleParameters_TreeNode::_internal_missingvaluetrackstruechild() const {
  return missingvaluetrackstruechild_;
}
inline bool TreeEnsembleParameters_TreeNode::missingvaluetrackstruechild() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.missingValueTracksTrueChild)
  return _internal_missingvaluetrackstruechild();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_missingvaluetrackstruechild(bool value) {
  
  missingvaluetrackstruechild_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_missingvaluetrackstruechild(bool value) {
  _internal_set_missingvaluetrackstruechild(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.missingValueTracksTrueChild)
}

// repeated .CoreML.Specification.TreeEnsembleParameters.TreeNode.EvaluationInfo evaluationInfo = 20;
inline int TreeEnsembleParameters_TreeNode::_internal_evaluationinfo_size() const {
  return evaluationinfo_.size();
}
inline int TreeEnsembleParameters_TreeNode::evaluationinfo_size() const {
  return _internal_evaluationinfo_size();
}
inline void TreeEnsembleParameters_TreeNode::clear_evaluationinfo() {
  evaluationinfo_.Clear();
}
inline ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* TreeEnsembleParameters_TreeNode::mutable_evaluationinfo(int index) {
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.TreeEnsembleParameters.TreeNode.evaluationInfo)
  return evaluationinfo_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo >*
TreeEnsembleParameters_TreeNode::mutable_evaluationinfo() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.TreeEnsembleParameters.TreeNode.evaluationInfo)
  return &evaluationinfo_;
}
inline const ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo& TreeEnsembleParameters_TreeNode::_internal_evaluationinfo(int index) const {
  return evaluationinfo_.Get(index);
}
inline const ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo& TreeEnsembleParameters_TreeNode::evaluationinfo(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.evaluationInfo)
  return _internal_evaluationinfo(index);
}
inline ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* TreeEnsembleParameters_TreeNode::_internal_add_evaluationinfo() {
  return evaluationinfo_.Add();
}
inline ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* TreeEnsembleParameters_TreeNode::add_evaluationinfo() {
  ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo* _add = _internal_add_evaluationinfo();
  // @@protoc_insertion_point(field_add:CoreML.Specification.TreeEnsembleParameters.TreeNode.evaluationInfo)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CoreML::Specification::TreeEnsembleParameters_TreeNode_EvaluationInfo >&
TreeEnsembleParameters_TreeNode::evaluationinfo() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.TreeEnsembleParameters.TreeNode.evaluationInfo)
  return evaluationinfo_;
}

// double relativeHitRate = 30;
inline void TreeEnsembleParameters_TreeNode::clear_relativehitrate() {
  relativehitrate_ = 0;
}
inline double TreeEnsembleParameters_TreeNode::_internal_relativehitrate() const {
  return relativehitrate_;
}
inline double TreeEnsembleParameters_TreeNode::relativehitrate() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.TreeNode.relativeHitRate)
  return _internal_relativehitrate();
}
inline void TreeEnsembleParameters_TreeNode::_internal_set_relativehitrate(double value) {
  
  relativehitrate_ = value;
}
inline void TreeEnsembleParameters_TreeNode::set_relativehitrate(double value) {
  _internal_set_relativehitrate(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.TreeNode.relativeHitRate)
}

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

// TreeEnsembleParameters

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

// uint64 numPredictionDimensions = 2;
inline void TreeEnsembleParameters::clear_numpredictiondimensions() {
  numpredictiondimensions_ = uint64_t{0u};
}
inline uint64_t TreeEnsembleParameters::_internal_numpredictiondimensions() const {
  return numpredictiondimensions_;
}
inline uint64_t TreeEnsembleParameters::numpredictiondimensions() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.numPredictionDimensions)
  return _internal_numpredictiondimensions();
}
inline void TreeEnsembleParameters::_internal_set_numpredictiondimensions(uint64_t value) {
  
  numpredictiondimensions_ = value;
}
inline void TreeEnsembleParameters::set_numpredictiondimensions(uint64_t value) {
  _internal_set_numpredictiondimensions(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.numPredictionDimensions)
}

// repeated double basePredictionValue = 3;
inline int TreeEnsembleParameters::_internal_basepredictionvalue_size() const {
  return basepredictionvalue_.size();
}
inline int TreeEnsembleParameters::basepredictionvalue_size() const {
  return _internal_basepredictionvalue_size();
}
inline void TreeEnsembleParameters::clear_basepredictionvalue() {
  basepredictionvalue_.Clear();
}
inline double TreeEnsembleParameters::_internal_basepredictionvalue(int index) const {
  return basepredictionvalue_.Get(index);
}
inline double TreeEnsembleParameters::basepredictionvalue(int index) const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleParameters.basePredictionValue)
  return _internal_basepredictionvalue(index);
}
inline void TreeEnsembleParameters::set_basepredictionvalue(int index, double value) {
  basepredictionvalue_.Set(index, value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleParameters.basePredictionValue)
}
inline void TreeEnsembleParameters::_internal_add_basepredictionvalue(double value) {
  basepredictionvalue_.Add(value);
}
inline void TreeEnsembleParameters::add_basepredictionvalue(double value) {
  _internal_add_basepredictionvalue(value);
  // @@protoc_insertion_point(field_add:CoreML.Specification.TreeEnsembleParameters.basePredictionValue)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TreeEnsembleParameters::_internal_basepredictionvalue() const {
  return basepredictionvalue_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TreeEnsembleParameters::basepredictionvalue() const {
  // @@protoc_insertion_point(field_list:CoreML.Specification.TreeEnsembleParameters.basePredictionValue)
  return _internal_basepredictionvalue();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TreeEnsembleParameters::_internal_mutable_basepredictionvalue() {
  return &basepredictionvalue_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TreeEnsembleParameters::mutable_basepredictionvalue() {
  // @@protoc_insertion_point(field_mutable_list:CoreML.Specification.TreeEnsembleParameters.basePredictionValue)
  return _internal_mutable_basepredictionvalue();
}

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

// TreeEnsembleClassifier

// .CoreML.Specification.TreeEnsembleParameters treeEnsemble = 1;
inline bool TreeEnsembleClassifier::_internal_has_treeensemble() const {
  return this != internal_default_instance() && treeensemble_ != nullptr;
}
inline bool TreeEnsembleClassifier::has_treeensemble() const {
  return _internal_has_treeensemble();
}
inline void TreeEnsembleClassifier::clear_treeensemble() {
  if (GetArenaForAllocation() == nullptr && treeensemble_ != nullptr) {
    delete treeensemble_;
  }
  treeensemble_ = nullptr;
}
inline const ::CoreML::Specification::TreeEnsembleParameters& TreeEnsembleClassifier::_internal_treeensemble() const {
  const ::CoreML::Specification::TreeEnsembleParameters* p = treeensemble_;
  return p != nullptr ? *p : reinterpret_cast<const ::CoreML::Specification::TreeEnsembleParameters&>(
      ::CoreML::Specification::_TreeEnsembleParameters_default_instance_);
}
inline const ::CoreML::Specification::TreeEnsembleParameters& TreeEnsembleClassifier::treeensemble() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleClassifier.treeEnsemble)
  return _internal_treeensemble();
}
inline void TreeEnsembleClassifier::unsafe_arena_set_allocated_treeensemble(
    ::CoreML::Specification::TreeEnsembleParameters* treeensemble) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(treeensemble_);
  }
  treeensemble_ = treeensemble;
  if (treeensemble) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.TreeEnsembleClassifier.treeEnsemble)
}
inline ::CoreML::Specification::TreeEnsembleParameters* TreeEnsembleClassifier::release_treeensemble() {
  
  ::CoreML::Specification::TreeEnsembleParameters* temp = treeensemble_;
  treeensemble_ = 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::TreeEnsembleParameters* TreeEnsembleClassifier::unsafe_arena_release_treeensemble() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.TreeEnsembleClassifier.treeEnsemble)
  
  ::CoreML::Specification::TreeEnsembleParameters* temp = treeensemble_;
  treeensemble_ = nullptr;
  return temp;
}
inline ::CoreML::Specification::TreeEnsembleParameters* TreeEnsembleClassifier::_internal_mutable_treeensemble() {
  
  if (treeensemble_ == nullptr) {
    auto* p = CreateMaybeMessage<::CoreML::Specification::TreeEnsembleParameters>(GetArenaForAllocation());
    treeensemble_ = p;
  }
  return treeensemble_;
}
inline ::CoreML::Specification::TreeEnsembleParameters* TreeEnsembleClassifier::mutable_treeensemble() {
  ::CoreML::Specification::TreeEnsembleParameters* _msg = _internal_mutable_treeensemble();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.TreeEnsembleClassifier.treeEnsemble)
  return _msg;
}
inline void TreeEnsembleClassifier::set_allocated_treeensemble(::CoreML::Specification::TreeEnsembleParameters* treeensemble) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete treeensemble_;
  }
  if (treeensemble) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::TreeEnsembleParameters>::GetOwningArena(treeensemble);
    if (message_arena != submessage_arena) {
      treeensemble = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, treeensemble, submessage_arena);
    }
    
  } else {
    
  }
  treeensemble_ = treeensemble;
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.TreeEnsembleClassifier.treeEnsemble)
}

// .CoreML.Specification.TreeEnsemblePostEvaluationTransform postEvaluationTransform = 2;
inline void TreeEnsembleClassifier::clear_postevaluationtransform() {
  postevaluationtransform_ = 0;
}
inline ::CoreML::Specification::TreeEnsemblePostEvaluationTransform TreeEnsembleClassifier::_internal_postevaluationtransform() const {
  return static_cast< ::CoreML::Specification::TreeEnsemblePostEvaluationTransform >(postevaluationtransform_);
}
inline ::CoreML::Specification::TreeEnsemblePostEvaluationTransform TreeEnsembleClassifier::postevaluationtransform() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleClassifier.postEvaluationTransform)
  return _internal_postevaluationtransform();
}
inline void TreeEnsembleClassifier::_internal_set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value) {
  
  postevaluationtransform_ = value;
}
inline void TreeEnsembleClassifier::set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value) {
  _internal_set_postevaluationtransform(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleClassifier.postEvaluationTransform)
}

// .CoreML.Specification.StringVector stringClassLabels = 100;
inline bool TreeEnsembleClassifier::_internal_has_stringclasslabels() const {
  return ClassLabels_case() == kStringClassLabels;
}
inline bool TreeEnsembleClassifier::has_stringclasslabels() const {
  return _internal_has_stringclasslabels();
}
inline void TreeEnsembleClassifier::set_has_stringclasslabels() {
  _oneof_case_[0] = kStringClassLabels;
}
inline ::CoreML::Specification::StringVector* TreeEnsembleClassifier::release_stringclasslabels() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.TreeEnsembleClassifier.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& TreeEnsembleClassifier::_internal_stringclasslabels() const {
  return _internal_has_stringclasslabels()
      ? *ClassLabels_.stringclasslabels_
      : reinterpret_cast< ::CoreML::Specification::StringVector&>(::CoreML::Specification::_StringVector_default_instance_);
}
inline const ::CoreML::Specification::StringVector& TreeEnsembleClassifier::stringclasslabels() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleClassifier.stringClassLabels)
  return _internal_stringclasslabels();
}
inline ::CoreML::Specification::StringVector* TreeEnsembleClassifier::unsafe_arena_release_stringclasslabels() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.TreeEnsembleClassifier.stringClassLabels)
  if (_internal_has_stringclasslabels()) {
    clear_has_ClassLabels();
    ::CoreML::Specification::StringVector* temp = ClassLabels_.stringclasslabels_;
    ClassLabels_.stringclasslabels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TreeEnsembleClassifier::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.TreeEnsembleClassifier.stringClassLabels)
}
inline ::CoreML::Specification::StringVector* TreeEnsembleClassifier::_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* TreeEnsembleClassifier::mutable_stringclasslabels() {
  ::CoreML::Specification::StringVector* _msg = _internal_mutable_stringclasslabels();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.TreeEnsembleClassifier.stringClassLabels)
  return _msg;
}

// .CoreML.Specification.Int64Vector int64ClassLabels = 101;
inline bool TreeEnsembleClassifier::_internal_has_int64classlabels() const {
  return ClassLabels_case() == kInt64ClassLabels;
}
inline bool TreeEnsembleClassifier::has_int64classlabels() const {
  return _internal_has_int64classlabels();
}
inline void TreeEnsembleClassifier::set_has_int64classlabels() {
  _oneof_case_[0] = kInt64ClassLabels;
}
inline ::CoreML::Specification::Int64Vector* TreeEnsembleClassifier::release_int64classlabels() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.TreeEnsembleClassifier.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& TreeEnsembleClassifier::_internal_int64classlabels() const {
  return _internal_has_int64classlabels()
      ? *ClassLabels_.int64classlabels_
      : reinterpret_cast< ::CoreML::Specification::Int64Vector&>(::CoreML::Specification::_Int64Vector_default_instance_);
}
inline const ::CoreML::Specification::Int64Vector& TreeEnsembleClassifier::int64classlabels() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleClassifier.int64ClassLabels)
  return _internal_int64classlabels();
}
inline ::CoreML::Specification::Int64Vector* TreeEnsembleClassifier::unsafe_arena_release_int64classlabels() {
  // @@protoc_insertion_point(field_unsafe_arena_release:CoreML.Specification.TreeEnsembleClassifier.int64ClassLabels)
  if (_internal_has_int64classlabels()) {
    clear_has_ClassLabels();
    ::CoreML::Specification::Int64Vector* temp = ClassLabels_.int64classlabels_;
    ClassLabels_.int64classlabels_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TreeEnsembleClassifier::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.TreeEnsembleClassifier.int64ClassLabels)
}
inline ::CoreML::Specification::Int64Vector* TreeEnsembleClassifier::_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* TreeEnsembleClassifier::mutable_int64classlabels() {
  ::CoreML::Specification::Int64Vector* _msg = _internal_mutable_int64classlabels();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.TreeEnsembleClassifier.int64ClassLabels)
  return _msg;
}

inline bool TreeEnsembleClassifier::has_ClassLabels() const {
  return ClassLabels_case() != CLASSLABELS_NOT_SET;
}
inline void TreeEnsembleClassifier::clear_has_ClassLabels() {
  _oneof_case_[0] = CLASSLABELS_NOT_SET;
}
inline TreeEnsembleClassifier::ClassLabelsCase TreeEnsembleClassifier::ClassLabels_case() const {
  return TreeEnsembleClassifier::ClassLabelsCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TreeEnsembleRegressor

// .CoreML.Specification.TreeEnsembleParameters treeEnsemble = 1;
inline bool TreeEnsembleRegressor::_internal_has_treeensemble() const {
  return this != internal_default_instance() && treeensemble_ != nullptr;
}
inline bool TreeEnsembleRegressor::has_treeensemble() const {
  return _internal_has_treeensemble();
}
inline void TreeEnsembleRegressor::clear_treeensemble() {
  if (GetArenaForAllocation() == nullptr && treeensemble_ != nullptr) {
    delete treeensemble_;
  }
  treeensemble_ = nullptr;
}
inline const ::CoreML::Specification::TreeEnsembleParameters& TreeEnsembleRegressor::_internal_treeensemble() const {
  const ::CoreML::Specification::TreeEnsembleParameters* p = treeensemble_;
  return p != nullptr ? *p : reinterpret_cast<const ::CoreML::Specification::TreeEnsembleParameters&>(
      ::CoreML::Specification::_TreeEnsembleParameters_default_instance_);
}
inline const ::CoreML::Specification::TreeEnsembleParameters& TreeEnsembleRegressor::treeensemble() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleRegressor.treeEnsemble)
  return _internal_treeensemble();
}
inline void TreeEnsembleRegressor::unsafe_arena_set_allocated_treeensemble(
    ::CoreML::Specification::TreeEnsembleParameters* treeensemble) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(treeensemble_);
  }
  treeensemble_ = treeensemble;
  if (treeensemble) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CoreML.Specification.TreeEnsembleRegressor.treeEnsemble)
}
inline ::CoreML::Specification::TreeEnsembleParameters* TreeEnsembleRegressor::release_treeensemble() {
  
  ::CoreML::Specification::TreeEnsembleParameters* temp = treeensemble_;
  treeensemble_ = 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::TreeEnsembleParameters* TreeEnsembleRegressor::unsafe_arena_release_treeensemble() {
  // @@protoc_insertion_point(field_release:CoreML.Specification.TreeEnsembleRegressor.treeEnsemble)
  
  ::CoreML::Specification::TreeEnsembleParameters* temp = treeensemble_;
  treeensemble_ = nullptr;
  return temp;
}
inline ::CoreML::Specification::TreeEnsembleParameters* TreeEnsembleRegressor::_internal_mutable_treeensemble() {
  
  if (treeensemble_ == nullptr) {
    auto* p = CreateMaybeMessage<::CoreML::Specification::TreeEnsembleParameters>(GetArenaForAllocation());
    treeensemble_ = p;
  }
  return treeensemble_;
}
inline ::CoreML::Specification::TreeEnsembleParameters* TreeEnsembleRegressor::mutable_treeensemble() {
  ::CoreML::Specification::TreeEnsembleParameters* _msg = _internal_mutable_treeensemble();
  // @@protoc_insertion_point(field_mutable:CoreML.Specification.TreeEnsembleRegressor.treeEnsemble)
  return _msg;
}
inline void TreeEnsembleRegressor::set_allocated_treeensemble(::CoreML::Specification::TreeEnsembleParameters* treeensemble) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete treeensemble_;
  }
  if (treeensemble) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::CoreML::Specification::TreeEnsembleParameters>::GetOwningArena(treeensemble);
    if (message_arena != submessage_arena) {
      treeensemble = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, treeensemble, submessage_arena);
    }
    
  } else {
    
  }
  treeensemble_ = treeensemble;
  // @@protoc_insertion_point(field_set_allocated:CoreML.Specification.TreeEnsembleRegressor.treeEnsemble)
}

// .CoreML.Specification.TreeEnsemblePostEvaluationTransform postEvaluationTransform = 2;
inline void TreeEnsembleRegressor::clear_postevaluationtransform() {
  postevaluationtransform_ = 0;
}
inline ::CoreML::Specification::TreeEnsemblePostEvaluationTransform TreeEnsembleRegressor::_internal_postevaluationtransform() const {
  return static_cast< ::CoreML::Specification::TreeEnsemblePostEvaluationTransform >(postevaluationtransform_);
}
inline ::CoreML::Specification::TreeEnsemblePostEvaluationTransform TreeEnsembleRegressor::postevaluationtransform() const {
  // @@protoc_insertion_point(field_get:CoreML.Specification.TreeEnsembleRegressor.postEvaluationTransform)
  return _internal_postevaluationtransform();
}
inline void TreeEnsembleRegressor::_internal_set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value) {
  
  postevaluationtransform_ = value;
}
inline void TreeEnsembleRegressor::set_postevaluationtransform(::CoreML::Specification::TreeEnsemblePostEvaluationTransform value) {
  _internal_set_postevaluationtransform(value);
  // @@protoc_insertion_point(field_set:CoreML.Specification.TreeEnsembleRegressor.postEvaluationTransform)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Specification
}  // namespace CoreML

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::CoreML::Specification::TreeEnsembleParameters_TreeNode_TreeNodeBehavior> : ::std::true_type {};
template <> struct is_proto_enum< ::CoreML::Specification::TreeEnsemblePostEvaluationTransform> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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