text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: tensorflow/contrib/boosted_trees/proto/quantiles.proto
  
  #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
  #include "tensorflow/contrib/boosted_trees/proto/quantiles.pb.h"
  
  #include <algorithm>
  
  #include <google/protobuf/stubs/common.h>
  #include <google/protobuf/stubs/port.h>
  #include <google/protobuf/stubs/once.h>
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/wire_format_lite_inl.h>
  #include <google/protobuf/descriptor.h>
  #include <google/protobuf/generated_message_reflection.h>
  #include <google/protobuf/reflection_ops.h>
  #include <google/protobuf/wire_format.h>
  // @@protoc_insertion_point(includes)
  
  namespace boosted_trees {
  
  namespace {
  
  const ::google::protobuf::Descriptor* QuantileConfig_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    QuantileConfig_reflection_ = NULL;
  const ::google::protobuf::Descriptor* QuantileEntry_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    QuantileEntry_reflection_ = NULL;
  const ::google::protobuf::Descriptor* QuantileSummaryState_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    QuantileSummaryState_reflection_ = NULL;
  const ::google::protobuf::Descriptor* QuantileStreamState_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    QuantileStreamState_reflection_ = NULL;
  
  }  // namespace
  
  
  void protobuf_AssignDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto() GOOGLE_ATTRIBUTE_COLD;
  void protobuf_AssignDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto() {
    protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    const ::google::protobuf::FileDescriptor* file =
      ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
        "tensorflow/contrib/boosted_trees/proto/quantiles.proto");
    GOOGLE_CHECK(file != NULL);
    QuantileConfig_descriptor_ = file->message_type(0);
    static const int QuantileConfig_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileConfig, eps_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileConfig, num_quantiles_),
    };
    QuantileConfig_reflection_ =
      ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
        QuantileConfig_descriptor_,
        QuantileConfig::internal_default_instance(),
        QuantileConfig_offsets_,
        -1,
        -1,
        -1,
        sizeof(QuantileConfig),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileConfig, _internal_metadata_));
    QuantileEntry_descriptor_ = file->message_type(1);
    static const int QuantileEntry_offsets_[4] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileEntry, value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileEntry, weight_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileEntry, min_rank_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileEntry, max_rank_),
    };
    QuantileEntry_reflection_ =
      ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
        QuantileEntry_descriptor_,
        QuantileEntry::internal_default_instance(),
        QuantileEntry_offsets_,
        -1,
        -1,
        -1,
        sizeof(QuantileEntry),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileEntry, _internal_metadata_));
    QuantileSummaryState_descriptor_ = file->message_type(2);
    static const int QuantileSummaryState_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileSummaryState, entries_),
    };
    QuantileSummaryState_reflection_ =
      ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
        QuantileSummaryState_descriptor_,
        QuantileSummaryState::internal_default_instance(),
        QuantileSummaryState_offsets_,
        -1,
        -1,
        -1,
        sizeof(QuantileSummaryState),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileSummaryState, _internal_metadata_));
    QuantileStreamState_descriptor_ = file->message_type(3);
    static const int QuantileStreamState_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileStreamState, summaries_),
    };
    QuantileStreamState_reflection_ =
      ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
        QuantileStreamState_descriptor_,
        QuantileStreamState::internal_default_instance(),
        QuantileStreamState_offsets_,
        -1,
        -1,
        -1,
        sizeof(QuantileStreamState),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QuantileStreamState, _internal_metadata_));
  }
  
  namespace {
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  void protobuf_AssignDescriptorsOnce() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                   &protobuf_AssignDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto);
  }
  
  void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
  void protobuf_RegisterTypes(const ::std::string&) {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        QuantileConfig_descriptor_, QuantileConfig::internal_default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        QuantileEntry_descriptor_, QuantileEntry::internal_default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        QuantileSummaryState_descriptor_, QuantileSummaryState::internal_default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        QuantileStreamState_descriptor_, QuantileStreamState::internal_default_instance());
  }
  
  }  // namespace
  
  void protobuf_ShutdownFile_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto() {
    QuantileConfig_default_instance_.Shutdown();
    delete QuantileConfig_reflection_;
    QuantileEntry_default_instance_.Shutdown();
    delete QuantileEntry_reflection_;
    QuantileSummaryState_default_instance_.Shutdown();
    delete QuantileSummaryState_reflection_;
    QuantileStreamState_default_instance_.Shutdown();
    delete QuantileStreamState_reflection_;
  }
  
  void protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_impl() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    QuantileConfig_default_instance_.DefaultConstruct();
    QuantileEntry_default_instance_.DefaultConstruct();
    QuantileSummaryState_default_instance_.DefaultConstruct();
    QuantileStreamState_default_instance_.DefaultConstruct();
    QuantileConfig_default_instance_.get_mutable()->InitAsDefaultInstance();
    QuantileEntry_default_instance_.get_mutable()->InitAsDefaultInstance();
    QuantileSummaryState_default_instance_.get_mutable()->InitAsDefaultInstance();
    QuantileStreamState_default_instance_.get_mutable()->InitAsDefaultInstance();
  }
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_once_);
  void protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto() {
    ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_once_,
                   &protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_impl);
  }
  void protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_impl() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      "\n6tensorflow/contrib/boosted_trees/proto"
      "/quantiles.proto\022\rboosted_trees\"4\n\016Quant"
      "ileConfig\022\013\n\003eps\030\001 \001(\001\022\025\n\rnum_quantiles\030"
      "\002 \001(\003\"R\n\rQuantileEntry\022\r\n\005value\030\001 \001(\002\022\016\n"
      "\006weight\030\002 \001(\002\022\020\n\010min_rank\030\003 \001(\002\022\020\n\010max_r"
      "ank\030\004 \001(\002\"E\n\024QuantileSummaryState\022-\n\007ent"
      "ries\030\001 \003(\0132\034.boosted_trees.QuantileEntry"
      "\"M\n\023QuantileStreamState\0226\n\tsummaries\030\001 \003"
      "(\0132#.boosted_trees.QuantileSummaryStateB"
      "\003\370\001\001b\006proto3", 372);
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
      "tensorflow/contrib/boosted_trees/proto/quantiles.proto", &protobuf_RegisterTypes);
    ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto);
  }
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_once_);
  void protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_once_,
                   &protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_impl);
  }
  // Force AddDescriptors() to be called at static initialization time.
  struct StaticDescriptorInitializer_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto {
    StaticDescriptorInitializer_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto() {
      protobuf_AddDesc_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    }
  } static_descriptor_initializer_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto_;
  
  namespace {
  
  static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN;
  static void MergeFromFail(int line) {
    ::google::protobuf::internal::MergeFromFail(__FILE__, line);
  }
  
  }  // namespace
  
  
  // ===================================================================
  
  #if !defined(_MSC_VER) || _MSC_VER >= 1900
  const int QuantileConfig::kEpsFieldNumber;
  const int QuantileConfig::kNumQuantilesFieldNumber;
  #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
  
  QuantileConfig::QuantileConfig()
    : ::google::protobuf::Message(), _internal_metadata_(NULL) {
    if (this != internal_default_instance()) protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    SharedCtor();
    // @@protoc_insertion_point(constructor:boosted_trees.QuantileConfig)
  }
  QuantileConfig::QuantileConfig(::google::protobuf::Arena* arena)
    : ::google::protobuf::Message(),
    _internal_metadata_(arena) {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
  #endif  // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:boosted_trees.QuantileConfig)
  }
  
  void QuantileConfig::InitAsDefaultInstance() {
  }
  
  QuantileConfig::QuantileConfig(const QuantileConfig& from)
    : ::google::protobuf::Message(),
      _internal_metadata_(NULL) {
    SharedCtor();
    UnsafeMergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:boosted_trees.QuantileConfig)
  }
  
  void QuantileConfig::SharedCtor() {
    ::memset(&eps_, 0, reinterpret_cast<char*>(&num_quantiles_) -
      reinterpret_cast<char*>(&eps_) + sizeof(num_quantiles_));
    _cached_size_ = 0;
  }
  
  QuantileConfig::~QuantileConfig() {
    // @@protoc_insertion_point(destructor:boosted_trees.QuantileConfig)
    SharedDtor();
  }
  
  void QuantileConfig::SharedDtor() {
    ::google::protobuf::Arena* arena = GetArenaNoVirtual();
    if (arena != NULL) {
      return;
    }
  
  }
  
  void QuantileConfig::ArenaDtor(void* object) {
    QuantileConfig* _this = reinterpret_cast< QuantileConfig* >(object);
    (void)_this;
  }
  void QuantileConfig::RegisterArenaDtor(::google::protobuf::Arena* arena) {
  }
  void QuantileConfig::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* QuantileConfig::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return QuantileConfig_descriptor_;
  }
  
  const QuantileConfig& QuantileConfig::default_instance() {
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    return *internal_default_instance();
  }
  
  ::google::protobuf::internal::ExplicitlyConstructed<QuantileConfig> QuantileConfig_default_instance_;
  
  QuantileConfig* QuantileConfig::New(::google::protobuf::Arena* arena) const {
    return ::google::protobuf::Arena::CreateMessage<QuantileConfig>(arena);
  }
  
  void QuantileConfig::Clear() {
  // @@protoc_insertion_point(message_clear_start:boosted_trees.QuantileConfig)
  #if defined(__clang__)
  #define ZR_HELPER_(f) \
    _Pragma("clang diagnostic push") \
    _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
    __builtin_offsetof(QuantileConfig, f) \
    _Pragma("clang diagnostic pop")
  #else
  #define ZR_HELPER_(f) reinterpret_cast<char*>(\
    &reinterpret_cast<QuantileConfig*>(16)->f)
  #endif
  
  #define ZR_(first, last) do {\
    ::memset(&(first), 0,\
             ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
  } while (0)
  
    ZR_(eps_, num_quantiles_);
  
  #undef ZR_HELPER_
  #undef ZR_
  
  }
  
  bool QuantileConfig::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:boosted_trees.QuantileConfig)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional double eps = 1;
        case 1: {
          if (tag == 9) {
  
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &eps_)));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(16)) goto parse_num_quantiles;
          break;
        }
  
        // optional int64 num_quantiles = 2;
        case 2: {
          if (tag == 16) {
           parse_num_quantiles:
  
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                   input, &num_quantiles_)));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:boosted_trees.QuantileConfig)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:boosted_trees.QuantileConfig)
    return false;
  #undef DO_
  }
  
  void QuantileConfig::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:boosted_trees.QuantileConfig)
    // optional double eps = 1;
    if (this->eps() != 0) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->eps(), output);
    }
  
    // optional int64 num_quantiles = 2;
    if (this->num_quantiles() != 0) {
      ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->num_quantiles(), output);
    }
  
    // @@protoc_insertion_point(serialize_end:boosted_trees.QuantileConfig)
  }
  
  ::google::protobuf::uint8* QuantileConfig::InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const {
    (void)deterministic; // Unused
    // @@protoc_insertion_point(serialize_to_array_start:boosted_trees.QuantileConfig)
    // optional double eps = 1;
    if (this->eps() != 0) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->eps(), target);
    }
  
    // optional int64 num_quantiles = 2;
    if (this->num_quantiles() != 0) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->num_quantiles(), target);
    }
  
    // @@protoc_insertion_point(serialize_to_array_end:boosted_trees.QuantileConfig)
    return target;
  }
  
  size_t QuantileConfig::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:boosted_trees.QuantileConfig)
    size_t total_size = 0;
  
    // optional double eps = 1;
    if (this->eps() != 0) {
      total_size += 1 + 8;
    }
  
    // optional int64 num_quantiles = 2;
    if (this->num_quantiles() != 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->num_quantiles());
    }
  
    int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void QuantileConfig::MergeFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:boosted_trees.QuantileConfig)
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    const QuantileConfig* source =
        ::google::protobuf::internal::DynamicCastToGenerated<const QuantileConfig>(
            &from);
    if (source == NULL) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:boosted_trees.QuantileConfig)
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:boosted_trees.QuantileConfig)
      UnsafeMergeFrom(*source);
    }
  }
  
  void QuantileConfig::MergeFrom(const QuantileConfig& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:boosted_trees.QuantileConfig)
    if (GOOGLE_PREDICT_TRUE(&from != this)) {
      UnsafeMergeFrom(from);
    } else {
      MergeFromFail(__LINE__);
    }
  }
  
  void QuantileConfig::UnsafeMergeFrom(const QuantileConfig& from) {
    GOOGLE_DCHECK(&from != this);
    if (from.eps() != 0) {
      set_eps(from.eps());
    }
    if (from.num_quantiles() != 0) {
      set_num_quantiles(from.num_quantiles());
    }
  }
  
  void QuantileConfig::CopyFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:boosted_trees.QuantileConfig)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void QuantileConfig::CopyFrom(const QuantileConfig& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:boosted_trees.QuantileConfig)
    if (&from == this) return;
    Clear();
    UnsafeMergeFrom(from);
  }
  
  bool QuantileConfig::IsInitialized() const {
  
    return true;
  }
  
  void QuantileConfig::Swap(QuantileConfig* other) {
    if (other == this) return;
    if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
      InternalSwap(other);
    } else {
      QuantileConfig temp;
      temp.UnsafeMergeFrom(*this);
      CopyFrom(*other);
      other->CopyFrom(temp);
    }
  }
  void QuantileConfig::UnsafeArenaSwap(QuantileConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
    InternalSwap(other);
  }
  void QuantileConfig::InternalSwap(QuantileConfig* other) {
    std::swap(eps_, other->eps_);
    std::swap(num_quantiles_, other->num_quantiles_);
    _internal_metadata_.Swap(&other->_internal_metadata_);
    std::swap(_cached_size_, other->_cached_size_);
  }
  
  ::google::protobuf::Metadata QuantileConfig::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = QuantileConfig_descriptor_;
    metadata.reflection = QuantileConfig_reflection_;
    return metadata;
  }
  
  #if PROTOBUF_INLINE_NOT_IN_HEADERS
  // QuantileConfig
  
  // optional double eps = 1;
  void QuantileConfig::clear_eps() {
    eps_ = 0;
  }
  double QuantileConfig::eps() const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileConfig.eps)
    return eps_;
  }
  void QuantileConfig::set_eps(double value) {
    
    eps_ = value;
    // @@protoc_insertion_point(field_set:boosted_trees.QuantileConfig.eps)
  }
  
  // optional int64 num_quantiles = 2;
  void QuantileConfig::clear_num_quantiles() {
    num_quantiles_ = GOOGLE_LONGLONG(0);
  }
  ::google::protobuf::int64 QuantileConfig::num_quantiles() const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileConfig.num_quantiles)
    return num_quantiles_;
  }
  void QuantileConfig::set_num_quantiles(::google::protobuf::int64 value) {
    
    num_quantiles_ = value;
    // @@protoc_insertion_point(field_set:boosted_trees.QuantileConfig.num_quantiles)
  }
  
  inline const QuantileConfig* QuantileConfig::internal_default_instance() {
    return &QuantileConfig_default_instance_.get();
  }
  #endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
  
  // ===================================================================
  
  #if !defined(_MSC_VER) || _MSC_VER >= 1900
  const int QuantileEntry::kValueFieldNumber;
  const int QuantileEntry::kWeightFieldNumber;
  const int QuantileEntry::kMinRankFieldNumber;
  const int QuantileEntry::kMaxRankFieldNumber;
  #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
  
  QuantileEntry::QuantileEntry()
    : ::google::protobuf::Message(), _internal_metadata_(NULL) {
    if (this != internal_default_instance()) protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    SharedCtor();
    // @@protoc_insertion_point(constructor:boosted_trees.QuantileEntry)
  }
  QuantileEntry::QuantileEntry(::google::protobuf::Arena* arena)
    : ::google::protobuf::Message(),
    _internal_metadata_(arena) {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
  #endif  // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:boosted_trees.QuantileEntry)
  }
  
  void QuantileEntry::InitAsDefaultInstance() {
  }
  
  QuantileEntry::QuantileEntry(const QuantileEntry& from)
    : ::google::protobuf::Message(),
      _internal_metadata_(NULL) {
    SharedCtor();
    UnsafeMergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:boosted_trees.QuantileEntry)
  }
  
  void QuantileEntry::SharedCtor() {
    ::memset(&value_, 0, reinterpret_cast<char*>(&max_rank_) -
      reinterpret_cast<char*>(&value_) + sizeof(max_rank_));
    _cached_size_ = 0;
  }
  
  QuantileEntry::~QuantileEntry() {
    // @@protoc_insertion_point(destructor:boosted_trees.QuantileEntry)
    SharedDtor();
  }
  
  void QuantileEntry::SharedDtor() {
    ::google::protobuf::Arena* arena = GetArenaNoVirtual();
    if (arena != NULL) {
      return;
    }
  
  }
  
  void QuantileEntry::ArenaDtor(void* object) {
    QuantileEntry* _this = reinterpret_cast< QuantileEntry* >(object);
    (void)_this;
  }
  void QuantileEntry::RegisterArenaDtor(::google::protobuf::Arena* arena) {
  }
  void QuantileEntry::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* QuantileEntry::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return QuantileEntry_descriptor_;
  }
  
  const QuantileEntry& QuantileEntry::default_instance() {
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    return *internal_default_instance();
  }
  
  ::google::protobuf::internal::ExplicitlyConstructed<QuantileEntry> QuantileEntry_default_instance_;
  
  QuantileEntry* QuantileEntry::New(::google::protobuf::Arena* arena) const {
    return ::google::protobuf::Arena::CreateMessage<QuantileEntry>(arena);
  }
  
  void QuantileEntry::Clear() {
  // @@protoc_insertion_point(message_clear_start:boosted_trees.QuantileEntry)
  #if defined(__clang__)
  #define ZR_HELPER_(f) \
    _Pragma("clang diagnostic push") \
    _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
    __builtin_offsetof(QuantileEntry, f) \
    _Pragma("clang diagnostic pop")
  #else
  #define ZR_HELPER_(f) reinterpret_cast<char*>(\
    &reinterpret_cast<QuantileEntry*>(16)->f)
  #endif
  
  #define ZR_(first, last) do {\
    ::memset(&(first), 0,\
             ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
  } while (0)
  
    ZR_(value_, max_rank_);
  
  #undef ZR_HELPER_
  #undef ZR_
  
  }
  
  bool QuantileEntry::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:boosted_trees.QuantileEntry)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional float value = 1;
        case 1: {
          if (tag == 13) {
  
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &value_)));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(21)) goto parse_weight;
          break;
        }
  
        // optional float weight = 2;
        case 2: {
          if (tag == 21) {
           parse_weight:
  
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &weight_)));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(29)) goto parse_min_rank;
          break;
        }
  
        // optional float min_rank = 3;
        case 3: {
          if (tag == 29) {
           parse_min_rank:
  
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &min_rank_)));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(37)) goto parse_max_rank;
          break;
        }
  
        // optional float max_rank = 4;
        case 4: {
          if (tag == 37) {
           parse_max_rank:
  
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                   input, &max_rank_)));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:boosted_trees.QuantileEntry)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:boosted_trees.QuantileEntry)
    return false;
  #undef DO_
  }
  
  void QuantileEntry::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:boosted_trees.QuantileEntry)
    // optional float value = 1;
    if (this->value() != 0) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->value(), output);
    }
  
    // optional float weight = 2;
    if (this->weight() != 0) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->weight(), output);
    }
  
    // optional float min_rank = 3;
    if (this->min_rank() != 0) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->min_rank(), output);
    }
  
    // optional float max_rank = 4;
    if (this->max_rank() != 0) {
      ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->max_rank(), output);
    }
  
    // @@protoc_insertion_point(serialize_end:boosted_trees.QuantileEntry)
  }
  
  ::google::protobuf::uint8* QuantileEntry::InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const {
    (void)deterministic; // Unused
    // @@protoc_insertion_point(serialize_to_array_start:boosted_trees.QuantileEntry)
    // optional float value = 1;
    if (this->value() != 0) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->value(), target);
    }
  
    // optional float weight = 2;
    if (this->weight() != 0) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->weight(), target);
    }
  
    // optional float min_rank = 3;
    if (this->min_rank() != 0) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->min_rank(), target);
    }
  
    // optional float max_rank = 4;
    if (this->max_rank() != 0) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->max_rank(), target);
    }
  
    // @@protoc_insertion_point(serialize_to_array_end:boosted_trees.QuantileEntry)
    return target;
  }
  
  size_t QuantileEntry::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:boosted_trees.QuantileEntry)
    size_t total_size = 0;
  
    // optional float value = 1;
    if (this->value() != 0) {
      total_size += 1 + 4;
    }
  
    // optional float weight = 2;
    if (this->weight() != 0) {
      total_size += 1 + 4;
    }
  
    // optional float min_rank = 3;
    if (this->min_rank() != 0) {
      total_size += 1 + 4;
    }
  
    // optional float max_rank = 4;
    if (this->max_rank() != 0) {
      total_size += 1 + 4;
    }
  
    int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void QuantileEntry::MergeFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:boosted_trees.QuantileEntry)
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    const QuantileEntry* source =
        ::google::protobuf::internal::DynamicCastToGenerated<const QuantileEntry>(
            &from);
    if (source == NULL) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:boosted_trees.QuantileEntry)
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:boosted_trees.QuantileEntry)
      UnsafeMergeFrom(*source);
    }
  }
  
  void QuantileEntry::MergeFrom(const QuantileEntry& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:boosted_trees.QuantileEntry)
    if (GOOGLE_PREDICT_TRUE(&from != this)) {
      UnsafeMergeFrom(from);
    } else {
      MergeFromFail(__LINE__);
    }
  }
  
  void QuantileEntry::UnsafeMergeFrom(const QuantileEntry& from) {
    GOOGLE_DCHECK(&from != this);
    if (from.value() != 0) {
      set_value(from.value());
    }
    if (from.weight() != 0) {
      set_weight(from.weight());
    }
    if (from.min_rank() != 0) {
      set_min_rank(from.min_rank());
    }
    if (from.max_rank() != 0) {
      set_max_rank(from.max_rank());
    }
  }
  
  void QuantileEntry::CopyFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:boosted_trees.QuantileEntry)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void QuantileEntry::CopyFrom(const QuantileEntry& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:boosted_trees.QuantileEntry)
    if (&from == this) return;
    Clear();
    UnsafeMergeFrom(from);
  }
  
  bool QuantileEntry::IsInitialized() const {
  
    return true;
  }
  
  void QuantileEntry::Swap(QuantileEntry* other) {
    if (other == this) return;
    if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
      InternalSwap(other);
    } else {
      QuantileEntry temp;
      temp.UnsafeMergeFrom(*this);
      CopyFrom(*other);
      other->CopyFrom(temp);
    }
  }
  void QuantileEntry::UnsafeArenaSwap(QuantileEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
    InternalSwap(other);
  }
  void QuantileEntry::InternalSwap(QuantileEntry* other) {
    std::swap(value_, other->value_);
    std::swap(weight_, other->weight_);
    std::swap(min_rank_, other->min_rank_);
    std::swap(max_rank_, other->max_rank_);
    _internal_metadata_.Swap(&other->_internal_metadata_);
    std::swap(_cached_size_, other->_cached_size_);
  }
  
  ::google::protobuf::Metadata QuantileEntry::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = QuantileEntry_descriptor_;
    metadata.reflection = QuantileEntry_reflection_;
    return metadata;
  }
  
  #if PROTOBUF_INLINE_NOT_IN_HEADERS
  // QuantileEntry
  
  // optional float value = 1;
  void QuantileEntry::clear_value() {
    value_ = 0;
  }
  float QuantileEntry::value() const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileEntry.value)
    return value_;
  }
  void QuantileEntry::set_value(float value) {
    
    value_ = value;
    // @@protoc_insertion_point(field_set:boosted_trees.QuantileEntry.value)
  }
  
  // optional float weight = 2;
  void QuantileEntry::clear_weight() {
    weight_ = 0;
  }
  float QuantileEntry::weight() const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileEntry.weight)
    return weight_;
  }
  void QuantileEntry::set_weight(float value) {
    
    weight_ = value;
    // @@protoc_insertion_point(field_set:boosted_trees.QuantileEntry.weight)
  }
  
  // optional float min_rank = 3;
  void QuantileEntry::clear_min_rank() {
    min_rank_ = 0;
  }
  float QuantileEntry::min_rank() const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileEntry.min_rank)
    return min_rank_;
  }
  void QuantileEntry::set_min_rank(float value) {
    
    min_rank_ = value;
    // @@protoc_insertion_point(field_set:boosted_trees.QuantileEntry.min_rank)
  }
  
  // optional float max_rank = 4;
  void QuantileEntry::clear_max_rank() {
    max_rank_ = 0;
  }
  float QuantileEntry::max_rank() const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileEntry.max_rank)
    return max_rank_;
  }
  void QuantileEntry::set_max_rank(float value) {
    
    max_rank_ = value;
    // @@protoc_insertion_point(field_set:boosted_trees.QuantileEntry.max_rank)
  }
  
  inline const QuantileEntry* QuantileEntry::internal_default_instance() {
    return &QuantileEntry_default_instance_.get();
  }
  #endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
  
  // ===================================================================
  
  #if !defined(_MSC_VER) || _MSC_VER >= 1900
  const int QuantileSummaryState::kEntriesFieldNumber;
  #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
  
  QuantileSummaryState::QuantileSummaryState()
    : ::google::protobuf::Message(), _internal_metadata_(NULL) {
    if (this != internal_default_instance()) protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    SharedCtor();
    // @@protoc_insertion_point(constructor:boosted_trees.QuantileSummaryState)
  }
  QuantileSummaryState::QuantileSummaryState(::google::protobuf::Arena* arena)
    : ::google::protobuf::Message(),
    _internal_metadata_(arena),
    entries_(arena) {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
  #endif  // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:boosted_trees.QuantileSummaryState)
  }
  
  void QuantileSummaryState::InitAsDefaultInstance() {
  }
  
  QuantileSummaryState::QuantileSummaryState(const QuantileSummaryState& from)
    : ::google::protobuf::Message(),
      _internal_metadata_(NULL) {
    SharedCtor();
    UnsafeMergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:boosted_trees.QuantileSummaryState)
  }
  
  void QuantileSummaryState::SharedCtor() {
    _cached_size_ = 0;
  }
  
  QuantileSummaryState::~QuantileSummaryState() {
    // @@protoc_insertion_point(destructor:boosted_trees.QuantileSummaryState)
    SharedDtor();
  }
  
  void QuantileSummaryState::SharedDtor() {
    ::google::protobuf::Arena* arena = GetArenaNoVirtual();
    if (arena != NULL) {
      return;
    }
  
  }
  
  void QuantileSummaryState::ArenaDtor(void* object) {
    QuantileSummaryState* _this = reinterpret_cast< QuantileSummaryState* >(object);
    (void)_this;
  }
  void QuantileSummaryState::RegisterArenaDtor(::google::protobuf::Arena* arena) {
  }
  void QuantileSummaryState::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* QuantileSummaryState::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return QuantileSummaryState_descriptor_;
  }
  
  const QuantileSummaryState& QuantileSummaryState::default_instance() {
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    return *internal_default_instance();
  }
  
  ::google::protobuf::internal::ExplicitlyConstructed<QuantileSummaryState> QuantileSummaryState_default_instance_;
  
  QuantileSummaryState* QuantileSummaryState::New(::google::protobuf::Arena* arena) const {
    return ::google::protobuf::Arena::CreateMessage<QuantileSummaryState>(arena);
  }
  
  void QuantileSummaryState::Clear() {
  // @@protoc_insertion_point(message_clear_start:boosted_trees.QuantileSummaryState)
    entries_.Clear();
  }
  
  bool QuantileSummaryState::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:boosted_trees.QuantileSummaryState)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // repeated .boosted_trees.QuantileEntry entries = 1;
        case 1: {
          if (tag == 10) {
            DO_(input->IncrementRecursionDepth());
           parse_loop_entries:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
                  input, add_entries()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(10)) goto parse_loop_entries;
          input->UnsafeDecrementRecursionDepth();
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:boosted_trees.QuantileSummaryState)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:boosted_trees.QuantileSummaryState)
    return false;
  #undef DO_
  }
  
  void QuantileSummaryState::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:boosted_trees.QuantileSummaryState)
    // repeated .boosted_trees.QuantileEntry entries = 1;
    for (unsigned int i = 0, n = this->entries_size(); i < n; i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        1, this->entries(i), output);
    }
  
    // @@protoc_insertion_point(serialize_end:boosted_trees.QuantileSummaryState)
  }
  
  ::google::protobuf::uint8* QuantileSummaryState::InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const {
    (void)deterministic; // Unused
    // @@protoc_insertion_point(serialize_to_array_start:boosted_trees.QuantileSummaryState)
    // repeated .boosted_trees.QuantileEntry entries = 1;
    for (unsigned int i = 0, n = this->entries_size(); i < n; i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageNoVirtualToArray(
          1, this->entries(i), false, target);
    }
  
    // @@protoc_insertion_point(serialize_to_array_end:boosted_trees.QuantileSummaryState)
    return target;
  }
  
  size_t QuantileSummaryState::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:boosted_trees.QuantileSummaryState)
    size_t total_size = 0;
  
    // repeated .boosted_trees.QuantileEntry entries = 1;
    {
      unsigned int count = this->entries_size();
      total_size += 1UL * count;
      for (unsigned int i = 0; i < count; i++) {
        total_size +=
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->entries(i));
      }
    }
  
    int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void QuantileSummaryState::MergeFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:boosted_trees.QuantileSummaryState)
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    const QuantileSummaryState* source =
        ::google::protobuf::internal::DynamicCastToGenerated<const QuantileSummaryState>(
            &from);
    if (source == NULL) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:boosted_trees.QuantileSummaryState)
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:boosted_trees.QuantileSummaryState)
      UnsafeMergeFrom(*source);
    }
  }
  
  void QuantileSummaryState::MergeFrom(const QuantileSummaryState& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:boosted_trees.QuantileSummaryState)
    if (GOOGLE_PREDICT_TRUE(&from != this)) {
      UnsafeMergeFrom(from);
    } else {
      MergeFromFail(__LINE__);
    }
  }
  
  void QuantileSummaryState::UnsafeMergeFrom(const QuantileSummaryState& from) {
    GOOGLE_DCHECK(&from != this);
    entries_.MergeFrom(from.entries_);
  }
  
  void QuantileSummaryState::CopyFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:boosted_trees.QuantileSummaryState)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void QuantileSummaryState::CopyFrom(const QuantileSummaryState& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:boosted_trees.QuantileSummaryState)
    if (&from == this) return;
    Clear();
    UnsafeMergeFrom(from);
  }
  
  bool QuantileSummaryState::IsInitialized() const {
  
    return true;
  }
  
  void QuantileSummaryState::Swap(QuantileSummaryState* other) {
    if (other == this) return;
    if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
      InternalSwap(other);
    } else {
      QuantileSummaryState temp;
      temp.UnsafeMergeFrom(*this);
      CopyFrom(*other);
      other->CopyFrom(temp);
    }
  }
  void QuantileSummaryState::UnsafeArenaSwap(QuantileSummaryState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
    InternalSwap(other);
  }
  void QuantileSummaryState::InternalSwap(QuantileSummaryState* other) {
    entries_.UnsafeArenaSwap(&other->entries_);
    _internal_metadata_.Swap(&other->_internal_metadata_);
    std::swap(_cached_size_, other->_cached_size_);
  }
  
  ::google::protobuf::Metadata QuantileSummaryState::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = QuantileSummaryState_descriptor_;
    metadata.reflection = QuantileSummaryState_reflection_;
    return metadata;
  }
  
  #if PROTOBUF_INLINE_NOT_IN_HEADERS
  // QuantileSummaryState
  
  // repeated .boosted_trees.QuantileEntry entries = 1;
  int QuantileSummaryState::entries_size() const {
    return entries_.size();
  }
  void QuantileSummaryState::clear_entries() {
    entries_.Clear();
  }
  const ::boosted_trees::QuantileEntry& QuantileSummaryState::entries(int index) const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileSummaryState.entries)
    return entries_.Get(index);
  }
  ::boosted_trees::QuantileEntry* QuantileSummaryState::mutable_entries(int index) {
    // @@protoc_insertion_point(field_mutable:boosted_trees.QuantileSummaryState.entries)
    return entries_.Mutable(index);
  }
  ::boosted_trees::QuantileEntry* QuantileSummaryState::add_entries() {
    // @@protoc_insertion_point(field_add:boosted_trees.QuantileSummaryState.entries)
    return entries_.Add();
  }
  ::google::protobuf::RepeatedPtrField< ::boosted_trees::QuantileEntry >*
  QuantileSummaryState::mutable_entries() {
    // @@protoc_insertion_point(field_mutable_list:boosted_trees.QuantileSummaryState.entries)
    return &entries_;
  }
  const ::google::protobuf::RepeatedPtrField< ::boosted_trees::QuantileEntry >&
  QuantileSummaryState::entries() const {
    // @@protoc_insertion_point(field_list:boosted_trees.QuantileSummaryState.entries)
    return entries_;
  }
  
  inline const QuantileSummaryState* QuantileSummaryState::internal_default_instance() {
    return &QuantileSummaryState_default_instance_.get();
  }
  #endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
  
  // ===================================================================
  
  #if !defined(_MSC_VER) || _MSC_VER >= 1900
  const int QuantileStreamState::kSummariesFieldNumber;
  #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
  
  QuantileStreamState::QuantileStreamState()
    : ::google::protobuf::Message(), _internal_metadata_(NULL) {
    if (this != internal_default_instance()) protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    SharedCtor();
    // @@protoc_insertion_point(constructor:boosted_trees.QuantileStreamState)
  }
  QuantileStreamState::QuantileStreamState(::google::protobuf::Arena* arena)
    : ::google::protobuf::Message(),
    _internal_metadata_(arena),
    summaries_(arena) {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
  #endif  // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:boosted_trees.QuantileStreamState)
  }
  
  void QuantileStreamState::InitAsDefaultInstance() {
  }
  
  QuantileStreamState::QuantileStreamState(const QuantileStreamState& from)
    : ::google::protobuf::Message(),
      _internal_metadata_(NULL) {
    SharedCtor();
    UnsafeMergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:boosted_trees.QuantileStreamState)
  }
  
  void QuantileStreamState::SharedCtor() {
    _cached_size_ = 0;
  }
  
  QuantileStreamState::~QuantileStreamState() {
    // @@protoc_insertion_point(destructor:boosted_trees.QuantileStreamState)
    SharedDtor();
  }
  
  void QuantileStreamState::SharedDtor() {
    ::google::protobuf::Arena* arena = GetArenaNoVirtual();
    if (arena != NULL) {
      return;
    }
  
  }
  
  void QuantileStreamState::ArenaDtor(void* object) {
    QuantileStreamState* _this = reinterpret_cast< QuantileStreamState* >(object);
    (void)_this;
  }
  void QuantileStreamState::RegisterArenaDtor(::google::protobuf::Arena* arena) {
  }
  void QuantileStreamState::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* QuantileStreamState::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return QuantileStreamState_descriptor_;
  }
  
  const QuantileStreamState& QuantileStreamState::default_instance() {
    protobuf_InitDefaults_tensorflow_2fcontrib_2fboosted_5ftrees_2fproto_2fquantiles_2eproto();
    return *internal_default_instance();
  }
  
  ::google::protobuf::internal::ExplicitlyConstructed<QuantileStreamState> QuantileStreamState_default_instance_;
  
  QuantileStreamState* QuantileStreamState::New(::google::protobuf::Arena* arena) const {
    return ::google::protobuf::Arena::CreateMessage<QuantileStreamState>(arena);
  }
  
  void QuantileStreamState::Clear() {
  // @@protoc_insertion_point(message_clear_start:boosted_trees.QuantileStreamState)
    summaries_.Clear();
  }
  
  bool QuantileStreamState::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:boosted_trees.QuantileStreamState)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // repeated .boosted_trees.QuantileSummaryState summaries = 1;
        case 1: {
          if (tag == 10) {
            DO_(input->IncrementRecursionDepth());
           parse_loop_summaries:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
                  input, add_summaries()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(10)) goto parse_loop_summaries;
          input->UnsafeDecrementRecursionDepth();
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:boosted_trees.QuantileStreamState)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:boosted_trees.QuantileStreamState)
    return false;
  #undef DO_
  }
  
  void QuantileStreamState::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:boosted_trees.QuantileStreamState)
    // repeated .boosted_trees.QuantileSummaryState summaries = 1;
    for (unsigned int i = 0, n = this->summaries_size(); i < n; i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        1, this->summaries(i), output);
    }
  
    // @@protoc_insertion_point(serialize_end:boosted_trees.QuantileStreamState)
  }
  
  ::google::protobuf::uint8* QuantileStreamState::InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const {
    (void)deterministic; // Unused
    // @@protoc_insertion_point(serialize_to_array_start:boosted_trees.QuantileStreamState)
    // repeated .boosted_trees.QuantileSummaryState summaries = 1;
    for (unsigned int i = 0, n = this->summaries_size(); i < n; i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageNoVirtualToArray(
          1, this->summaries(i), false, target);
    }
  
    // @@protoc_insertion_point(serialize_to_array_end:boosted_trees.QuantileStreamState)
    return target;
  }
  
  size_t QuantileStreamState::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:boosted_trees.QuantileStreamState)
    size_t total_size = 0;
  
    // repeated .boosted_trees.QuantileSummaryState summaries = 1;
    {
      unsigned int count = this->summaries_size();
      total_size += 1UL * count;
      for (unsigned int i = 0; i < count; i++) {
        total_size +=
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->summaries(i));
      }
    }
  
    int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = cached_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void QuantileStreamState::MergeFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:boosted_trees.QuantileStreamState)
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    const QuantileStreamState* source =
        ::google::protobuf::internal::DynamicCastToGenerated<const QuantileStreamState>(
            &from);
    if (source == NULL) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:boosted_trees.QuantileStreamState)
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:boosted_trees.QuantileStreamState)
      UnsafeMergeFrom(*source);
    }
  }
  
  void QuantileStreamState::MergeFrom(const QuantileStreamState& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:boosted_trees.QuantileStreamState)
    if (GOOGLE_PREDICT_TRUE(&from != this)) {
      UnsafeMergeFrom(from);
    } else {
      MergeFromFail(__LINE__);
    }
  }
  
  void QuantileStreamState::UnsafeMergeFrom(const QuantileStreamState& from) {
    GOOGLE_DCHECK(&from != this);
    summaries_.MergeFrom(from.summaries_);
  }
  
  void QuantileStreamState::CopyFrom(const ::google::protobuf::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:boosted_trees.QuantileStreamState)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void QuantileStreamState::CopyFrom(const QuantileStreamState& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:boosted_trees.QuantileStreamState)
    if (&from == this) return;
    Clear();
    UnsafeMergeFrom(from);
  }
  
  bool QuantileStreamState::IsInitialized() const {
  
    return true;
  }
  
  void QuantileStreamState::Swap(QuantileStreamState* other) {
    if (other == this) return;
    if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
      InternalSwap(other);
    } else {
      QuantileStreamState temp;
      temp.UnsafeMergeFrom(*this);
      CopyFrom(*other);
      other->CopyFrom(temp);
    }
  }
  void QuantileStreamState::UnsafeArenaSwap(QuantileStreamState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
    InternalSwap(other);
  }
  void QuantileStreamState::InternalSwap(QuantileStreamState* other) {
    summaries_.UnsafeArenaSwap(&other->summaries_);
    _internal_metadata_.Swap(&other->_internal_metadata_);
    std::swap(_cached_size_, other->_cached_size_);
  }
  
  ::google::protobuf::Metadata QuantileStreamState::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = QuantileStreamState_descriptor_;
    metadata.reflection = QuantileStreamState_reflection_;
    return metadata;
  }
  
  #if PROTOBUF_INLINE_NOT_IN_HEADERS
  // QuantileStreamState
  
  // repeated .boosted_trees.QuantileSummaryState summaries = 1;
  int QuantileStreamState::summaries_size() const {
    return summaries_.size();
  }
  void QuantileStreamState::clear_summaries() {
    summaries_.Clear();
  }
  const ::boosted_trees::QuantileSummaryState& QuantileStreamState::summaries(int index) const {
    // @@protoc_insertion_point(field_get:boosted_trees.QuantileStreamState.summaries)
    return summaries_.Get(index);
  }
  ::boosted_trees::QuantileSummaryState* QuantileStreamState::mutable_summaries(int index) {
    // @@protoc_insertion_point(field_mutable:boosted_trees.QuantileStreamState.summaries)
    return summaries_.Mutable(index);
  }
  ::boosted_trees::QuantileSummaryState* QuantileStreamState::add_summaries() {
    // @@protoc_insertion_point(field_add:boosted_trees.QuantileStreamState.summaries)
    return summaries_.Add();
  }
  ::google::protobuf::RepeatedPtrField< ::boosted_trees::QuantileSummaryState >*
  QuantileStreamState::mutable_summaries() {
    // @@protoc_insertion_point(field_mutable_list:boosted_trees.QuantileStreamState.summaries)
    return &summaries_;
  }
  const ::google::protobuf::RepeatedPtrField< ::boosted_trees::QuantileSummaryState >&
  QuantileStreamState::summaries() const {
    // @@protoc_insertion_point(field_list:boosted_trees.QuantileStreamState.summaries)
    return summaries_;
  }
  
  inline const QuantileStreamState* QuantileStreamState::internal_default_instance() {
    return &QuantileStreamState_default_instance_.get();
  }
  #endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace boosted_trees
  
  // @@protoc_insertion_point(global_scope)
  