// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: distributions/io/schema.proto

#ifndef PROTOBUF_distributions_2fio_2fschema_2eproto__INCLUDED
#define PROTOBUF_distributions_2fio_2fschema_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 2004000
#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 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

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

namespace protobuf {
namespace distributions {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();

class Clustering;
class Clustering_PitmanYor;
class Clustering_LowEntropy;
class BetaBernoulli;
class BetaBernoulli_Shared;
class BetaBernoulli_GridPrior;
class BetaBernoulli_Group;
class DirichletDiscrete;
class DirichletDiscrete_Shared;
class DirichletDiscrete_GridPrior;
class DirichletDiscrete_Group;
class DirichletProcessDiscrete;
class DirichletProcessDiscrete_Shared;
class DirichletProcessDiscrete_GridPrior;
class DirichletProcessDiscrete_Group;
class PitmanYorProcessDiscrete;
class PitmanYorProcessDiscrete_Shared;
class PitmanYorProcessDiscrete_GridPrior;
class PitmanYorProcessDiscrete_Group;
class GammaPoisson;
class GammaPoisson_Shared;
class GammaPoisson_GridPrior;
class GammaPoisson_Group;
class BetaNegativeBinomial;
class BetaNegativeBinomial_Shared;
class BetaNegativeBinomial_GridPrior;
class BetaNegativeBinomial_Group;
class NormalInverseChiSq;
class NormalInverseChiSq_Shared;
class NormalInverseChiSq_GridPrior;
class NormalInverseChiSq_Group;

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

class Clustering_PitmanYor : public ::google::protobuf::Message {
 public:
  Clustering_PitmanYor();
  virtual ~Clustering_PitmanYor();
  
  Clustering_PitmanYor(const Clustering_PitmanYor& from);
  
  inline Clustering_PitmanYor& operator=(const Clustering_PitmanYor& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Clustering_PitmanYor& default_instance();
  
  void Swap(Clustering_PitmanYor* other);
  
  // implements Message ----------------------------------------------
  
  Clustering_PitmanYor* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Clustering_PitmanYor& from);
  void MergeFrom(const Clustering_PitmanYor& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float alpha = 1;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha() const;
  inline void set_alpha(float value);
  
  // required float d = 2;
  inline bool has_d() const;
  inline void clear_d();
  static const int kDFieldNumber = 2;
  inline float d() const;
  inline void set_d(float value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.Clustering.PitmanYor)
 private:
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_d();
  inline void clear_has_d();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float alpha_;
  float d_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static Clustering_PitmanYor* default_instance_;
};
// -------------------------------------------------------------------

class Clustering_LowEntropy : public ::google::protobuf::Message {
 public:
  Clustering_LowEntropy();
  virtual ~Clustering_LowEntropy();
  
  Clustering_LowEntropy(const Clustering_LowEntropy& from);
  
  inline Clustering_LowEntropy& operator=(const Clustering_LowEntropy& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Clustering_LowEntropy& default_instance();
  
  void Swap(Clustering_LowEntropy* other);
  
  // implements Message ----------------------------------------------
  
  Clustering_LowEntropy* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Clustering_LowEntropy& from);
  void MergeFrom(const Clustering_LowEntropy& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint64 dataset_size = 1;
  inline bool has_dataset_size() const;
  inline void clear_dataset_size();
  static const int kDatasetSizeFieldNumber = 1;
  inline ::google::protobuf::uint64 dataset_size() const;
  inline void set_dataset_size(::google::protobuf::uint64 value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.Clustering.LowEntropy)
 private:
  inline void set_has_dataset_size();
  inline void clear_has_dataset_size();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint64 dataset_size_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static Clustering_LowEntropy* default_instance_;
};
// -------------------------------------------------------------------

class Clustering : public ::google::protobuf::Message {
 public:
  Clustering();
  virtual ~Clustering();
  
  Clustering(const Clustering& from);
  
  inline Clustering& operator=(const Clustering& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Clustering& default_instance();
  
  void Swap(Clustering* other);
  
  // implements Message ----------------------------------------------
  
  Clustering* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Clustering& from);
  void MergeFrom(const Clustering& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Clustering_PitmanYor PitmanYor;
  typedef Clustering_LowEntropy LowEntropy;
  
  // accessors -------------------------------------------------------
  
  // optional .protobuf.distributions.Clustering.PitmanYor pitman_yor = 1;
  inline bool has_pitman_yor() const;
  inline void clear_pitman_yor();
  static const int kPitmanYorFieldNumber = 1;
  inline const ::protobuf::distributions::Clustering_PitmanYor& pitman_yor() const;
  inline ::protobuf::distributions::Clustering_PitmanYor* mutable_pitman_yor();
  inline ::protobuf::distributions::Clustering_PitmanYor* release_pitman_yor();
  
  // optional .protobuf.distributions.Clustering.LowEntropy low_entropy = 2;
  inline bool has_low_entropy() const;
  inline void clear_low_entropy();
  static const int kLowEntropyFieldNumber = 2;
  inline const ::protobuf::distributions::Clustering_LowEntropy& low_entropy() const;
  inline ::protobuf::distributions::Clustering_LowEntropy* mutable_low_entropy();
  inline ::protobuf::distributions::Clustering_LowEntropy* release_low_entropy();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.Clustering)
 private:
  inline void set_has_pitman_yor();
  inline void clear_has_pitman_yor();
  inline void set_has_low_entropy();
  inline void clear_has_low_entropy();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::protobuf::distributions::Clustering_PitmanYor* pitman_yor_;
  ::protobuf::distributions::Clustering_LowEntropy* low_entropy_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static Clustering* default_instance_;
};
// -------------------------------------------------------------------

class BetaBernoulli_Shared : public ::google::protobuf::Message {
 public:
  BetaBernoulli_Shared();
  virtual ~BetaBernoulli_Shared();
  
  BetaBernoulli_Shared(const BetaBernoulli_Shared& from);
  
  inline BetaBernoulli_Shared& operator=(const BetaBernoulli_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaBernoulli_Shared& default_instance();
  
  void Swap(BetaBernoulli_Shared* other);
  
  // implements Message ----------------------------------------------
  
  BetaBernoulli_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaBernoulli_Shared& from);
  void MergeFrom(const BetaBernoulli_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float alpha = 1;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha() const;
  inline void set_alpha(float value);
  
  // required float beta = 2;
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 2;
  inline float beta() const;
  inline void set_beta(float value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaBernoulli.Shared)
 private:
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float alpha_;
  float beta_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaBernoulli_Shared* default_instance_;
};
// -------------------------------------------------------------------

class BetaBernoulli_GridPrior : public ::google::protobuf::Message {
 public:
  BetaBernoulli_GridPrior();
  virtual ~BetaBernoulli_GridPrior();
  
  BetaBernoulli_GridPrior(const BetaBernoulli_GridPrior& from);
  
  inline BetaBernoulli_GridPrior& operator=(const BetaBernoulli_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaBernoulli_GridPrior& default_instance();
  
  void Swap(BetaBernoulli_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  BetaBernoulli_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaBernoulli_GridPrior& from);
  void MergeFrom(const BetaBernoulli_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float alpha = 1;
  inline int alpha_size() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha(int index) const;
  inline void set_alpha(int index, float value);
  inline void add_alpha(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      alpha() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_alpha();
  
  // repeated float beta = 2;
  inline int beta_size() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 2;
  inline float beta(int index) const;
  inline void set_beta(int index, float value);
  inline void add_beta(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      beta() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_beta();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaBernoulli.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > alpha_;
  ::google::protobuf::RepeatedField< float > beta_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaBernoulli_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class BetaBernoulli_Group : public ::google::protobuf::Message {
 public:
  BetaBernoulli_Group();
  virtual ~BetaBernoulli_Group();
  
  BetaBernoulli_Group(const BetaBernoulli_Group& from);
  
  inline BetaBernoulli_Group& operator=(const BetaBernoulli_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaBernoulli_Group& default_instance();
  
  void Swap(BetaBernoulli_Group* other);
  
  // implements Message ----------------------------------------------
  
  BetaBernoulli_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaBernoulli_Group& from);
  void MergeFrom(const BetaBernoulli_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint64 heads = 1;
  inline bool has_heads() const;
  inline void clear_heads();
  static const int kHeadsFieldNumber = 1;
  inline ::google::protobuf::uint64 heads() const;
  inline void set_heads(::google::protobuf::uint64 value);
  
  // required uint64 tails = 2;
  inline bool has_tails() const;
  inline void clear_tails();
  static const int kTailsFieldNumber = 2;
  inline ::google::protobuf::uint64 tails() const;
  inline void set_tails(::google::protobuf::uint64 value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaBernoulli.Group)
 private:
  inline void set_has_heads();
  inline void clear_has_heads();
  inline void set_has_tails();
  inline void clear_has_tails();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint64 heads_;
  ::google::protobuf::uint64 tails_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaBernoulli_Group* default_instance_;
};
// -------------------------------------------------------------------

class BetaBernoulli : public ::google::protobuf::Message {
 public:
  BetaBernoulli();
  virtual ~BetaBernoulli();
  
  BetaBernoulli(const BetaBernoulli& from);
  
  inline BetaBernoulli& operator=(const BetaBernoulli& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaBernoulli& default_instance();
  
  void Swap(BetaBernoulli* other);
  
  // implements Message ----------------------------------------------
  
  BetaBernoulli* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaBernoulli& from);
  void MergeFrom(const BetaBernoulli& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef BetaBernoulli_Shared Shared;
  typedef BetaBernoulli_GridPrior GridPrior;
  typedef BetaBernoulli_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaBernoulli)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaBernoulli* default_instance_;
};
// -------------------------------------------------------------------

class DirichletDiscrete_Shared : public ::google::protobuf::Message {
 public:
  DirichletDiscrete_Shared();
  virtual ~DirichletDiscrete_Shared();
  
  DirichletDiscrete_Shared(const DirichletDiscrete_Shared& from);
  
  inline DirichletDiscrete_Shared& operator=(const DirichletDiscrete_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletDiscrete_Shared& default_instance();
  
  void Swap(DirichletDiscrete_Shared* other);
  
  // implements Message ----------------------------------------------
  
  DirichletDiscrete_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletDiscrete_Shared& from);
  void MergeFrom(const DirichletDiscrete_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float alphas = 1;
  inline int alphas_size() const;
  inline void clear_alphas();
  static const int kAlphasFieldNumber = 1;
  inline float alphas(int index) const;
  inline void set_alphas(int index, float value);
  inline void add_alphas(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      alphas() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_alphas();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletDiscrete.Shared)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > alphas_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletDiscrete_Shared* default_instance_;
};
// -------------------------------------------------------------------

class DirichletDiscrete_GridPrior : public ::google::protobuf::Message {
 public:
  DirichletDiscrete_GridPrior();
  virtual ~DirichletDiscrete_GridPrior();
  
  DirichletDiscrete_GridPrior(const DirichletDiscrete_GridPrior& from);
  
  inline DirichletDiscrete_GridPrior& operator=(const DirichletDiscrete_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletDiscrete_GridPrior& default_instance();
  
  void Swap(DirichletDiscrete_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  DirichletDiscrete_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletDiscrete_GridPrior& from);
  void MergeFrom(const DirichletDiscrete_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float alpha = 1;
  inline int alpha_size() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha(int index) const;
  inline void set_alpha(int index, float value);
  inline void add_alpha(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      alpha() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_alpha();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletDiscrete.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > alpha_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletDiscrete_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class DirichletDiscrete_Group : public ::google::protobuf::Message {
 public:
  DirichletDiscrete_Group();
  virtual ~DirichletDiscrete_Group();
  
  DirichletDiscrete_Group(const DirichletDiscrete_Group& from);
  
  inline DirichletDiscrete_Group& operator=(const DirichletDiscrete_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletDiscrete_Group& default_instance();
  
  void Swap(DirichletDiscrete_Group* other);
  
  // implements Message ----------------------------------------------
  
  DirichletDiscrete_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletDiscrete_Group& from);
  void MergeFrom(const DirichletDiscrete_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated uint64 counts = 1;
  inline int counts_size() const;
  inline void clear_counts();
  static const int kCountsFieldNumber = 1;
  inline ::google::protobuf::uint64 counts(int index) const;
  inline void set_counts(int index, ::google::protobuf::uint64 value);
  inline void add_counts(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      counts() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_counts();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletDiscrete.Group)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > counts_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletDiscrete_Group* default_instance_;
};
// -------------------------------------------------------------------

class DirichletDiscrete : public ::google::protobuf::Message {
 public:
  DirichletDiscrete();
  virtual ~DirichletDiscrete();
  
  DirichletDiscrete(const DirichletDiscrete& from);
  
  inline DirichletDiscrete& operator=(const DirichletDiscrete& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletDiscrete& default_instance();
  
  void Swap(DirichletDiscrete* other);
  
  // implements Message ----------------------------------------------
  
  DirichletDiscrete* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletDiscrete& from);
  void MergeFrom(const DirichletDiscrete& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef DirichletDiscrete_Shared Shared;
  typedef DirichletDiscrete_GridPrior GridPrior;
  typedef DirichletDiscrete_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletDiscrete)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletDiscrete* default_instance_;
};
// -------------------------------------------------------------------

class DirichletProcessDiscrete_Shared : public ::google::protobuf::Message {
 public:
  DirichletProcessDiscrete_Shared();
  virtual ~DirichletProcessDiscrete_Shared();
  
  DirichletProcessDiscrete_Shared(const DirichletProcessDiscrete_Shared& from);
  
  inline DirichletProcessDiscrete_Shared& operator=(const DirichletProcessDiscrete_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletProcessDiscrete_Shared& default_instance();
  
  void Swap(DirichletProcessDiscrete_Shared* other);
  
  // implements Message ----------------------------------------------
  
  DirichletProcessDiscrete_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletProcessDiscrete_Shared& from);
  void MergeFrom(const DirichletProcessDiscrete_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float gamma = 1;
  inline bool has_gamma() const;
  inline void clear_gamma();
  static const int kGammaFieldNumber = 1;
  inline float gamma() const;
  inline void set_gamma(float value);
  
  // required float alpha = 2;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 2;
  inline float alpha() const;
  inline void set_alpha(float value);
  
  // repeated uint32 values = 3;
  inline int values_size() const;
  inline void clear_values();
  static const int kValuesFieldNumber = 3;
  inline ::google::protobuf::uint32 values(int index) const;
  inline void set_values(int index, ::google::protobuf::uint32 value);
  inline void add_values(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      values() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_values();
  
  // repeated float betas = 4;
  inline int betas_size() const;
  inline void clear_betas();
  static const int kBetasFieldNumber = 4;
  inline float betas(int index) const;
  inline void set_betas(int index, float value);
  inline void add_betas(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      betas() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_betas();
  
  // repeated uint64 counts = 5;
  inline int counts_size() const;
  inline void clear_counts();
  static const int kCountsFieldNumber = 5;
  inline ::google::protobuf::uint64 counts(int index) const;
  inline void set_counts(int index, ::google::protobuf::uint64 value);
  inline void add_counts(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      counts() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_counts();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletProcessDiscrete.Shared)
 private:
  inline void set_has_gamma();
  inline void clear_has_gamma();
  inline void set_has_alpha();
  inline void clear_has_alpha();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float gamma_;
  float alpha_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > values_;
  ::google::protobuf::RepeatedField< float > betas_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > counts_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletProcessDiscrete_Shared* default_instance_;
};
// -------------------------------------------------------------------

class DirichletProcessDiscrete_GridPrior : public ::google::protobuf::Message {
 public:
  DirichletProcessDiscrete_GridPrior();
  virtual ~DirichletProcessDiscrete_GridPrior();
  
  DirichletProcessDiscrete_GridPrior(const DirichletProcessDiscrete_GridPrior& from);
  
  inline DirichletProcessDiscrete_GridPrior& operator=(const DirichletProcessDiscrete_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletProcessDiscrete_GridPrior& default_instance();
  
  void Swap(DirichletProcessDiscrete_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  DirichletProcessDiscrete_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletProcessDiscrete_GridPrior& from);
  void MergeFrom(const DirichletProcessDiscrete_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float gamma = 1;
  inline int gamma_size() const;
  inline void clear_gamma();
  static const int kGammaFieldNumber = 1;
  inline float gamma(int index) const;
  inline void set_gamma(int index, float value);
  inline void add_gamma(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      gamma() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_gamma();
  
  // repeated float alpha = 2;
  inline int alpha_size() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 2;
  inline float alpha(int index) const;
  inline void set_alpha(int index, float value);
  inline void add_alpha(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      alpha() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_alpha();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletProcessDiscrete.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > gamma_;
  ::google::protobuf::RepeatedField< float > alpha_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletProcessDiscrete_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class DirichletProcessDiscrete_Group : public ::google::protobuf::Message {
 public:
  DirichletProcessDiscrete_Group();
  virtual ~DirichletProcessDiscrete_Group();
  
  DirichletProcessDiscrete_Group(const DirichletProcessDiscrete_Group& from);
  
  inline DirichletProcessDiscrete_Group& operator=(const DirichletProcessDiscrete_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletProcessDiscrete_Group& default_instance();
  
  void Swap(DirichletProcessDiscrete_Group* other);
  
  // implements Message ----------------------------------------------
  
  DirichletProcessDiscrete_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletProcessDiscrete_Group& from);
  void MergeFrom(const DirichletProcessDiscrete_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated uint32 keys = 1;
  inline int keys_size() const;
  inline void clear_keys();
  static const int kKeysFieldNumber = 1;
  inline ::google::protobuf::uint32 keys(int index) const;
  inline void set_keys(int index, ::google::protobuf::uint32 value);
  inline void add_keys(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      keys() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_keys();
  
  // repeated uint64 values = 2;
  inline int values_size() const;
  inline void clear_values();
  static const int kValuesFieldNumber = 2;
  inline ::google::protobuf::uint64 values(int index) const;
  inline void set_values(int index, ::google::protobuf::uint64 value);
  inline void add_values(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      values() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_values();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletProcessDiscrete.Group)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > keys_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > values_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletProcessDiscrete_Group* default_instance_;
};
// -------------------------------------------------------------------

class DirichletProcessDiscrete : public ::google::protobuf::Message {
 public:
  DirichletProcessDiscrete();
  virtual ~DirichletProcessDiscrete();
  
  DirichletProcessDiscrete(const DirichletProcessDiscrete& from);
  
  inline DirichletProcessDiscrete& operator=(const DirichletProcessDiscrete& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DirichletProcessDiscrete& default_instance();
  
  void Swap(DirichletProcessDiscrete* other);
  
  // implements Message ----------------------------------------------
  
  DirichletProcessDiscrete* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DirichletProcessDiscrete& from);
  void MergeFrom(const DirichletProcessDiscrete& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef DirichletProcessDiscrete_Shared Shared;
  typedef DirichletProcessDiscrete_GridPrior GridPrior;
  typedef DirichletProcessDiscrete_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.DirichletProcessDiscrete)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static DirichletProcessDiscrete* default_instance_;
};
// -------------------------------------------------------------------

class PitmanYorProcessDiscrete_Shared : public ::google::protobuf::Message {
 public:
  PitmanYorProcessDiscrete_Shared();
  virtual ~PitmanYorProcessDiscrete_Shared();
  
  PitmanYorProcessDiscrete_Shared(const PitmanYorProcessDiscrete_Shared& from);
  
  inline PitmanYorProcessDiscrete_Shared& operator=(const PitmanYorProcessDiscrete_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const PitmanYorProcessDiscrete_Shared& default_instance();
  
  void Swap(PitmanYorProcessDiscrete_Shared* other);
  
  // implements Message ----------------------------------------------
  
  PitmanYorProcessDiscrete_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PitmanYorProcessDiscrete_Shared& from);
  void MergeFrom(const PitmanYorProcessDiscrete_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float alpha = 1;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha() const;
  inline void set_alpha(float value);
  
  // repeated float d = 2;
  inline int d_size() const;
  inline void clear_d();
  static const int kDFieldNumber = 2;
  inline float d(int index) const;
  inline void set_d(int index, float value);
  inline void add_d(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      d() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_d();
  
  // repeated uint64 counts = 3;
  inline int counts_size() const;
  inline void clear_counts();
  static const int kCountsFieldNumber = 3;
  inline ::google::protobuf::uint64 counts(int index) const;
  inline void set_counts(int index, ::google::protobuf::uint64 value);
  inline void add_counts(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      counts() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_counts();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.PitmanYorProcessDiscrete.Shared)
 private:
  inline void set_has_alpha();
  inline void clear_has_alpha();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > d_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > counts_;
  float alpha_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static PitmanYorProcessDiscrete_Shared* default_instance_;
};
// -------------------------------------------------------------------

class PitmanYorProcessDiscrete_GridPrior : public ::google::protobuf::Message {
 public:
  PitmanYorProcessDiscrete_GridPrior();
  virtual ~PitmanYorProcessDiscrete_GridPrior();
  
  PitmanYorProcessDiscrete_GridPrior(const PitmanYorProcessDiscrete_GridPrior& from);
  
  inline PitmanYorProcessDiscrete_GridPrior& operator=(const PitmanYorProcessDiscrete_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const PitmanYorProcessDiscrete_GridPrior& default_instance();
  
  void Swap(PitmanYorProcessDiscrete_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  PitmanYorProcessDiscrete_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PitmanYorProcessDiscrete_GridPrior& from);
  void MergeFrom(const PitmanYorProcessDiscrete_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated .protobuf.distributions.Clustering.PitmanYor alpha_d = 1;
  inline int alpha_d_size() const;
  inline void clear_alpha_d();
  static const int kAlphaDFieldNumber = 1;
  inline const ::protobuf::distributions::Clustering_PitmanYor& alpha_d(int index) const;
  inline ::protobuf::distributions::Clustering_PitmanYor* mutable_alpha_d(int index);
  inline ::protobuf::distributions::Clustering_PitmanYor* add_alpha_d();
  inline const ::google::protobuf::RepeatedPtrField< ::protobuf::distributions::Clustering_PitmanYor >&
      alpha_d() const;
  inline ::google::protobuf::RepeatedPtrField< ::protobuf::distributions::Clustering_PitmanYor >*
      mutable_alpha_d();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.PitmanYorProcessDiscrete.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::protobuf::distributions::Clustering_PitmanYor > alpha_d_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static PitmanYorProcessDiscrete_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class PitmanYorProcessDiscrete_Group : public ::google::protobuf::Message {
 public:
  PitmanYorProcessDiscrete_Group();
  virtual ~PitmanYorProcessDiscrete_Group();
  
  PitmanYorProcessDiscrete_Group(const PitmanYorProcessDiscrete_Group& from);
  
  inline PitmanYorProcessDiscrete_Group& operator=(const PitmanYorProcessDiscrete_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const PitmanYorProcessDiscrete_Group& default_instance();
  
  void Swap(PitmanYorProcessDiscrete_Group* other);
  
  // implements Message ----------------------------------------------
  
  PitmanYorProcessDiscrete_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PitmanYorProcessDiscrete_Group& from);
  void MergeFrom(const PitmanYorProcessDiscrete_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated uint32 keys = 1;
  inline int keys_size() const;
  inline void clear_keys();
  static const int kKeysFieldNumber = 1;
  inline ::google::protobuf::uint32 keys(int index) const;
  inline void set_keys(int index, ::google::protobuf::uint32 value);
  inline void add_keys(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      keys() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_keys();
  
  // repeated uint64 values = 2;
  inline int values_size() const;
  inline void clear_values();
  static const int kValuesFieldNumber = 2;
  inline ::google::protobuf::uint64 values(int index) const;
  inline void set_values(int index, ::google::protobuf::uint64 value);
  inline void add_values(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      values() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_values();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.PitmanYorProcessDiscrete.Group)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > keys_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > values_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static PitmanYorProcessDiscrete_Group* default_instance_;
};
// -------------------------------------------------------------------

class PitmanYorProcessDiscrete : public ::google::protobuf::Message {
 public:
  PitmanYorProcessDiscrete();
  virtual ~PitmanYorProcessDiscrete();
  
  PitmanYorProcessDiscrete(const PitmanYorProcessDiscrete& from);
  
  inline PitmanYorProcessDiscrete& operator=(const PitmanYorProcessDiscrete& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const PitmanYorProcessDiscrete& default_instance();
  
  void Swap(PitmanYorProcessDiscrete* other);
  
  // implements Message ----------------------------------------------
  
  PitmanYorProcessDiscrete* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PitmanYorProcessDiscrete& from);
  void MergeFrom(const PitmanYorProcessDiscrete& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef PitmanYorProcessDiscrete_Shared Shared;
  typedef PitmanYorProcessDiscrete_GridPrior GridPrior;
  typedef PitmanYorProcessDiscrete_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.PitmanYorProcessDiscrete)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static PitmanYorProcessDiscrete* default_instance_;
};
// -------------------------------------------------------------------

class GammaPoisson_Shared : public ::google::protobuf::Message {
 public:
  GammaPoisson_Shared();
  virtual ~GammaPoisson_Shared();
  
  GammaPoisson_Shared(const GammaPoisson_Shared& from);
  
  inline GammaPoisson_Shared& operator=(const GammaPoisson_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const GammaPoisson_Shared& default_instance();
  
  void Swap(GammaPoisson_Shared* other);
  
  // implements Message ----------------------------------------------
  
  GammaPoisson_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GammaPoisson_Shared& from);
  void MergeFrom(const GammaPoisson_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float alpha = 1;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha() const;
  inline void set_alpha(float value);
  
  // required float inv_beta = 2;
  inline bool has_inv_beta() const;
  inline void clear_inv_beta();
  static const int kInvBetaFieldNumber = 2;
  inline float inv_beta() const;
  inline void set_inv_beta(float value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.GammaPoisson.Shared)
 private:
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_inv_beta();
  inline void clear_has_inv_beta();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float alpha_;
  float inv_beta_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static GammaPoisson_Shared* default_instance_;
};
// -------------------------------------------------------------------

class GammaPoisson_GridPrior : public ::google::protobuf::Message {
 public:
  GammaPoisson_GridPrior();
  virtual ~GammaPoisson_GridPrior();
  
  GammaPoisson_GridPrior(const GammaPoisson_GridPrior& from);
  
  inline GammaPoisson_GridPrior& operator=(const GammaPoisson_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const GammaPoisson_GridPrior& default_instance();
  
  void Swap(GammaPoisson_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  GammaPoisson_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GammaPoisson_GridPrior& from);
  void MergeFrom(const GammaPoisson_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float alpha = 1;
  inline int alpha_size() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha(int index) const;
  inline void set_alpha(int index, float value);
  inline void add_alpha(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      alpha() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_alpha();
  
  // repeated float inv_beta = 2;
  inline int inv_beta_size() const;
  inline void clear_inv_beta();
  static const int kInvBetaFieldNumber = 2;
  inline float inv_beta(int index) const;
  inline void set_inv_beta(int index, float value);
  inline void add_inv_beta(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      inv_beta() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_inv_beta();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.GammaPoisson.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > alpha_;
  ::google::protobuf::RepeatedField< float > inv_beta_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static GammaPoisson_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class GammaPoisson_Group : public ::google::protobuf::Message {
 public:
  GammaPoisson_Group();
  virtual ~GammaPoisson_Group();
  
  GammaPoisson_Group(const GammaPoisson_Group& from);
  
  inline GammaPoisson_Group& operator=(const GammaPoisson_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const GammaPoisson_Group& default_instance();
  
  void Swap(GammaPoisson_Group* other);
  
  // implements Message ----------------------------------------------
  
  GammaPoisson_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GammaPoisson_Group& from);
  void MergeFrom(const GammaPoisson_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint64 count = 1;
  inline bool has_count() const;
  inline void clear_count();
  static const int kCountFieldNumber = 1;
  inline ::google::protobuf::uint64 count() const;
  inline void set_count(::google::protobuf::uint64 value);
  
  // required uint64 sum = 2;
  inline bool has_sum() const;
  inline void clear_sum();
  static const int kSumFieldNumber = 2;
  inline ::google::protobuf::uint64 sum() const;
  inline void set_sum(::google::protobuf::uint64 value);
  
  // required float log_prod = 3;
  inline bool has_log_prod() const;
  inline void clear_log_prod();
  static const int kLogProdFieldNumber = 3;
  inline float log_prod() const;
  inline void set_log_prod(float value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.GammaPoisson.Group)
 private:
  inline void set_has_count();
  inline void clear_has_count();
  inline void set_has_sum();
  inline void clear_has_sum();
  inline void set_has_log_prod();
  inline void clear_has_log_prod();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint64 count_;
  ::google::protobuf::uint64 sum_;
  float log_prod_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static GammaPoisson_Group* default_instance_;
};
// -------------------------------------------------------------------

class GammaPoisson : public ::google::protobuf::Message {
 public:
  GammaPoisson();
  virtual ~GammaPoisson();
  
  GammaPoisson(const GammaPoisson& from);
  
  inline GammaPoisson& operator=(const GammaPoisson& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const GammaPoisson& default_instance();
  
  void Swap(GammaPoisson* other);
  
  // implements Message ----------------------------------------------
  
  GammaPoisson* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GammaPoisson& from);
  void MergeFrom(const GammaPoisson& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef GammaPoisson_Shared Shared;
  typedef GammaPoisson_GridPrior GridPrior;
  typedef GammaPoisson_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.GammaPoisson)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static GammaPoisson* default_instance_;
};
// -------------------------------------------------------------------

class BetaNegativeBinomial_Shared : public ::google::protobuf::Message {
 public:
  BetaNegativeBinomial_Shared();
  virtual ~BetaNegativeBinomial_Shared();
  
  BetaNegativeBinomial_Shared(const BetaNegativeBinomial_Shared& from);
  
  inline BetaNegativeBinomial_Shared& operator=(const BetaNegativeBinomial_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaNegativeBinomial_Shared& default_instance();
  
  void Swap(BetaNegativeBinomial_Shared* other);
  
  // implements Message ----------------------------------------------
  
  BetaNegativeBinomial_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaNegativeBinomial_Shared& from);
  void MergeFrom(const BetaNegativeBinomial_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float alpha = 1;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha() const;
  inline void set_alpha(float value);
  
  // required float beta = 2;
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 2;
  inline float beta() const;
  inline void set_beta(float value);
  
  // required uint64 r = 3;
  inline bool has_r() const;
  inline void clear_r();
  static const int kRFieldNumber = 3;
  inline ::google::protobuf::uint64 r() const;
  inline void set_r(::google::protobuf::uint64 value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaNegativeBinomial.Shared)
 private:
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  inline void set_has_r();
  inline void clear_has_r();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float alpha_;
  float beta_;
  ::google::protobuf::uint64 r_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaNegativeBinomial_Shared* default_instance_;
};
// -------------------------------------------------------------------

class BetaNegativeBinomial_GridPrior : public ::google::protobuf::Message {
 public:
  BetaNegativeBinomial_GridPrior();
  virtual ~BetaNegativeBinomial_GridPrior();
  
  BetaNegativeBinomial_GridPrior(const BetaNegativeBinomial_GridPrior& from);
  
  inline BetaNegativeBinomial_GridPrior& operator=(const BetaNegativeBinomial_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaNegativeBinomial_GridPrior& default_instance();
  
  void Swap(BetaNegativeBinomial_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  BetaNegativeBinomial_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaNegativeBinomial_GridPrior& from);
  void MergeFrom(const BetaNegativeBinomial_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float alpha = 1;
  inline int alpha_size() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 1;
  inline float alpha(int index) const;
  inline void set_alpha(int index, float value);
  inline void add_alpha(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      alpha() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_alpha();
  
  // repeated float beta = 2;
  inline int beta_size() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 2;
  inline float beta(int index) const;
  inline void set_beta(int index, float value);
  inline void add_beta(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      beta() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_beta();
  
  // repeated uint64 r = 3;
  inline int r_size() const;
  inline void clear_r();
  static const int kRFieldNumber = 3;
  inline ::google::protobuf::uint64 r(int index) const;
  inline void set_r(int index, ::google::protobuf::uint64 value);
  inline void add_r(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      r() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_r();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaNegativeBinomial.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > alpha_;
  ::google::protobuf::RepeatedField< float > beta_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > r_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaNegativeBinomial_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class BetaNegativeBinomial_Group : public ::google::protobuf::Message {
 public:
  BetaNegativeBinomial_Group();
  virtual ~BetaNegativeBinomial_Group();
  
  BetaNegativeBinomial_Group(const BetaNegativeBinomial_Group& from);
  
  inline BetaNegativeBinomial_Group& operator=(const BetaNegativeBinomial_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaNegativeBinomial_Group& default_instance();
  
  void Swap(BetaNegativeBinomial_Group* other);
  
  // implements Message ----------------------------------------------
  
  BetaNegativeBinomial_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaNegativeBinomial_Group& from);
  void MergeFrom(const BetaNegativeBinomial_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint64 count = 1;
  inline bool has_count() const;
  inline void clear_count();
  static const int kCountFieldNumber = 1;
  inline ::google::protobuf::uint64 count() const;
  inline void set_count(::google::protobuf::uint64 value);
  
  // required uint64 sum = 2;
  inline bool has_sum() const;
  inline void clear_sum();
  static const int kSumFieldNumber = 2;
  inline ::google::protobuf::uint64 sum() const;
  inline void set_sum(::google::protobuf::uint64 value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaNegativeBinomial.Group)
 private:
  inline void set_has_count();
  inline void clear_has_count();
  inline void set_has_sum();
  inline void clear_has_sum();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint64 count_;
  ::google::protobuf::uint64 sum_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaNegativeBinomial_Group* default_instance_;
};
// -------------------------------------------------------------------

class BetaNegativeBinomial : public ::google::protobuf::Message {
 public:
  BetaNegativeBinomial();
  virtual ~BetaNegativeBinomial();
  
  BetaNegativeBinomial(const BetaNegativeBinomial& from);
  
  inline BetaNegativeBinomial& operator=(const BetaNegativeBinomial& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const BetaNegativeBinomial& default_instance();
  
  void Swap(BetaNegativeBinomial* other);
  
  // implements Message ----------------------------------------------
  
  BetaNegativeBinomial* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BetaNegativeBinomial& from);
  void MergeFrom(const BetaNegativeBinomial& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef BetaNegativeBinomial_Shared Shared;
  typedef BetaNegativeBinomial_GridPrior GridPrior;
  typedef BetaNegativeBinomial_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.BetaNegativeBinomial)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static BetaNegativeBinomial* default_instance_;
};
// -------------------------------------------------------------------

class NormalInverseChiSq_Shared : public ::google::protobuf::Message {
 public:
  NormalInverseChiSq_Shared();
  virtual ~NormalInverseChiSq_Shared();
  
  NormalInverseChiSq_Shared(const NormalInverseChiSq_Shared& from);
  
  inline NormalInverseChiSq_Shared& operator=(const NormalInverseChiSq_Shared& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const NormalInverseChiSq_Shared& default_instance();
  
  void Swap(NormalInverseChiSq_Shared* other);
  
  // implements Message ----------------------------------------------
  
  NormalInverseChiSq_Shared* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NormalInverseChiSq_Shared& from);
  void MergeFrom(const NormalInverseChiSq_Shared& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float mu = 1;
  inline bool has_mu() const;
  inline void clear_mu();
  static const int kMuFieldNumber = 1;
  inline float mu() const;
  inline void set_mu(float value);
  
  // required float kappa = 2;
  inline bool has_kappa() const;
  inline void clear_kappa();
  static const int kKappaFieldNumber = 2;
  inline float kappa() const;
  inline void set_kappa(float value);
  
  // required float sigmasq = 3;
  inline bool has_sigmasq() const;
  inline void clear_sigmasq();
  static const int kSigmasqFieldNumber = 3;
  inline float sigmasq() const;
  inline void set_sigmasq(float value);
  
  // required float nu = 4;
  inline bool has_nu() const;
  inline void clear_nu();
  static const int kNuFieldNumber = 4;
  inline float nu() const;
  inline void set_nu(float value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.NormalInverseChiSq.Shared)
 private:
  inline void set_has_mu();
  inline void clear_has_mu();
  inline void set_has_kappa();
  inline void clear_has_kappa();
  inline void set_has_sigmasq();
  inline void clear_has_sigmasq();
  inline void set_has_nu();
  inline void clear_has_nu();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float mu_;
  float kappa_;
  float sigmasq_;
  float nu_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static NormalInverseChiSq_Shared* default_instance_;
};
// -------------------------------------------------------------------

class NormalInverseChiSq_GridPrior : public ::google::protobuf::Message {
 public:
  NormalInverseChiSq_GridPrior();
  virtual ~NormalInverseChiSq_GridPrior();
  
  NormalInverseChiSq_GridPrior(const NormalInverseChiSq_GridPrior& from);
  
  inline NormalInverseChiSq_GridPrior& operator=(const NormalInverseChiSq_GridPrior& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const NormalInverseChiSq_GridPrior& default_instance();
  
  void Swap(NormalInverseChiSq_GridPrior* other);
  
  // implements Message ----------------------------------------------
  
  NormalInverseChiSq_GridPrior* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NormalInverseChiSq_GridPrior& from);
  void MergeFrom(const NormalInverseChiSq_GridPrior& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated float mu = 1;
  inline int mu_size() const;
  inline void clear_mu();
  static const int kMuFieldNumber = 1;
  inline float mu(int index) const;
  inline void set_mu(int index, float value);
  inline void add_mu(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      mu() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_mu();
  
  // repeated float kappa = 2;
  inline int kappa_size() const;
  inline void clear_kappa();
  static const int kKappaFieldNumber = 2;
  inline float kappa(int index) const;
  inline void set_kappa(int index, float value);
  inline void add_kappa(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      kappa() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_kappa();
  
  // repeated float sigmasq = 3;
  inline int sigmasq_size() const;
  inline void clear_sigmasq();
  static const int kSigmasqFieldNumber = 3;
  inline float sigmasq(int index) const;
  inline void set_sigmasq(int index, float value);
  inline void add_sigmasq(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      sigmasq() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_sigmasq();
  
  // repeated float nu = 4;
  inline int nu_size() const;
  inline void clear_nu();
  static const int kNuFieldNumber = 4;
  inline float nu(int index) const;
  inline void set_nu(int index, float value);
  inline void add_nu(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      nu() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_nu();
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.NormalInverseChiSq.GridPrior)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< float > mu_;
  ::google::protobuf::RepeatedField< float > kappa_;
  ::google::protobuf::RepeatedField< float > sigmasq_;
  ::google::protobuf::RepeatedField< float > nu_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static NormalInverseChiSq_GridPrior* default_instance_;
};
// -------------------------------------------------------------------

class NormalInverseChiSq_Group : public ::google::protobuf::Message {
 public:
  NormalInverseChiSq_Group();
  virtual ~NormalInverseChiSq_Group();
  
  NormalInverseChiSq_Group(const NormalInverseChiSq_Group& from);
  
  inline NormalInverseChiSq_Group& operator=(const NormalInverseChiSq_Group& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const NormalInverseChiSq_Group& default_instance();
  
  void Swap(NormalInverseChiSq_Group* other);
  
  // implements Message ----------------------------------------------
  
  NormalInverseChiSq_Group* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NormalInverseChiSq_Group& from);
  void MergeFrom(const NormalInverseChiSq_Group& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint64 count = 1;
  inline bool has_count() const;
  inline void clear_count();
  static const int kCountFieldNumber = 1;
  inline ::google::protobuf::uint64 count() const;
  inline void set_count(::google::protobuf::uint64 value);
  
  // required float mean = 2;
  inline bool has_mean() const;
  inline void clear_mean();
  static const int kMeanFieldNumber = 2;
  inline float mean() const;
  inline void set_mean(float value);
  
  // required float count_times_variance = 3;
  inline bool has_count_times_variance() const;
  inline void clear_count_times_variance();
  static const int kCountTimesVarianceFieldNumber = 3;
  inline float count_times_variance() const;
  inline void set_count_times_variance(float value);
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.NormalInverseChiSq.Group)
 private:
  inline void set_has_count();
  inline void clear_has_count();
  inline void set_has_mean();
  inline void clear_has_mean();
  inline void set_has_count_times_variance();
  inline void clear_has_count_times_variance();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint64 count_;
  float mean_;
  float count_times_variance_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static NormalInverseChiSq_Group* default_instance_;
};
// -------------------------------------------------------------------

class NormalInverseChiSq : public ::google::protobuf::Message {
 public:
  NormalInverseChiSq();
  virtual ~NormalInverseChiSq();
  
  NormalInverseChiSq(const NormalInverseChiSq& from);
  
  inline NormalInverseChiSq& operator=(const NormalInverseChiSq& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const NormalInverseChiSq& default_instance();
  
  void Swap(NormalInverseChiSq* other);
  
  // implements Message ----------------------------------------------
  
  NormalInverseChiSq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const NormalInverseChiSq& from);
  void MergeFrom(const NormalInverseChiSq& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef NormalInverseChiSq_Shared Shared;
  typedef NormalInverseChiSq_GridPrior GridPrior;
  typedef NormalInverseChiSq_Group Group;
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf.distributions.NormalInverseChiSq)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_AssignDesc_distributions_2fio_2fschema_2eproto();
  friend void protobuf_ShutdownFile_distributions_2fio_2fschema_2eproto();
  
  void InitAsDefaultInstance();
  static NormalInverseChiSq* default_instance_;
};
// ===================================================================


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

// Clustering_PitmanYor

// required float alpha = 1;
inline bool Clustering_PitmanYor::has_alpha() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Clustering_PitmanYor::set_has_alpha() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Clustering_PitmanYor::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Clustering_PitmanYor::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float Clustering_PitmanYor::alpha() const {
  return alpha_;
}
inline void Clustering_PitmanYor::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// required float d = 2;
inline bool Clustering_PitmanYor::has_d() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Clustering_PitmanYor::set_has_d() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Clustering_PitmanYor::clear_has_d() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Clustering_PitmanYor::clear_d() {
  d_ = 0;
  clear_has_d();
}
inline float Clustering_PitmanYor::d() const {
  return d_;
}
inline void Clustering_PitmanYor::set_d(float value) {
  set_has_d();
  d_ = value;
}

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

// Clustering_LowEntropy

// required uint64 dataset_size = 1;
inline bool Clustering_LowEntropy::has_dataset_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Clustering_LowEntropy::set_has_dataset_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Clustering_LowEntropy::clear_has_dataset_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Clustering_LowEntropy::clear_dataset_size() {
  dataset_size_ = GOOGLE_ULONGLONG(0);
  clear_has_dataset_size();
}
inline ::google::protobuf::uint64 Clustering_LowEntropy::dataset_size() const {
  return dataset_size_;
}
inline void Clustering_LowEntropy::set_dataset_size(::google::protobuf::uint64 value) {
  set_has_dataset_size();
  dataset_size_ = value;
}

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

// Clustering

// optional .protobuf.distributions.Clustering.PitmanYor pitman_yor = 1;
inline bool Clustering::has_pitman_yor() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Clustering::set_has_pitman_yor() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Clustering::clear_has_pitman_yor() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Clustering::clear_pitman_yor() {
  if (pitman_yor_ != NULL) pitman_yor_->::protobuf::distributions::Clustering_PitmanYor::Clear();
  clear_has_pitman_yor();
}
inline const ::protobuf::distributions::Clustering_PitmanYor& Clustering::pitman_yor() const {
  return pitman_yor_ != NULL ? *pitman_yor_ : *default_instance_->pitman_yor_;
}
inline ::protobuf::distributions::Clustering_PitmanYor* Clustering::mutable_pitman_yor() {
  set_has_pitman_yor();
  if (pitman_yor_ == NULL) pitman_yor_ = new ::protobuf::distributions::Clustering_PitmanYor;
  return pitman_yor_;
}
inline ::protobuf::distributions::Clustering_PitmanYor* Clustering::release_pitman_yor() {
  clear_has_pitman_yor();
  ::protobuf::distributions::Clustering_PitmanYor* temp = pitman_yor_;
  pitman_yor_ = NULL;
  return temp;
}

// optional .protobuf.distributions.Clustering.LowEntropy low_entropy = 2;
inline bool Clustering::has_low_entropy() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Clustering::set_has_low_entropy() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Clustering::clear_has_low_entropy() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Clustering::clear_low_entropy() {
  if (low_entropy_ != NULL) low_entropy_->::protobuf::distributions::Clustering_LowEntropy::Clear();
  clear_has_low_entropy();
}
inline const ::protobuf::distributions::Clustering_LowEntropy& Clustering::low_entropy() const {
  return low_entropy_ != NULL ? *low_entropy_ : *default_instance_->low_entropy_;
}
inline ::protobuf::distributions::Clustering_LowEntropy* Clustering::mutable_low_entropy() {
  set_has_low_entropy();
  if (low_entropy_ == NULL) low_entropy_ = new ::protobuf::distributions::Clustering_LowEntropy;
  return low_entropy_;
}
inline ::protobuf::distributions::Clustering_LowEntropy* Clustering::release_low_entropy() {
  clear_has_low_entropy();
  ::protobuf::distributions::Clustering_LowEntropy* temp = low_entropy_;
  low_entropy_ = NULL;
  return temp;
}

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

// BetaBernoulli_Shared

// required float alpha = 1;
inline bool BetaBernoulli_Shared::has_alpha() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BetaBernoulli_Shared::set_has_alpha() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BetaBernoulli_Shared::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BetaBernoulli_Shared::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float BetaBernoulli_Shared::alpha() const {
  return alpha_;
}
inline void BetaBernoulli_Shared::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// required float beta = 2;
inline bool BetaBernoulli_Shared::has_beta() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BetaBernoulli_Shared::set_has_beta() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BetaBernoulli_Shared::clear_has_beta() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BetaBernoulli_Shared::clear_beta() {
  beta_ = 0;
  clear_has_beta();
}
inline float BetaBernoulli_Shared::beta() const {
  return beta_;
}
inline void BetaBernoulli_Shared::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

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

// BetaBernoulli_GridPrior

// repeated float alpha = 1;
inline int BetaBernoulli_GridPrior::alpha_size() const {
  return alpha_.size();
}
inline void BetaBernoulli_GridPrior::clear_alpha() {
  alpha_.Clear();
}
inline float BetaBernoulli_GridPrior::alpha(int index) const {
  return alpha_.Get(index);
}
inline void BetaBernoulli_GridPrior::set_alpha(int index, float value) {
  alpha_.Set(index, value);
}
inline void BetaBernoulli_GridPrior::add_alpha(float value) {
  alpha_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BetaBernoulli_GridPrior::alpha() const {
  return alpha_;
}
inline ::google::protobuf::RepeatedField< float >*
BetaBernoulli_GridPrior::mutable_alpha() {
  return &alpha_;
}

// repeated float beta = 2;
inline int BetaBernoulli_GridPrior::beta_size() const {
  return beta_.size();
}
inline void BetaBernoulli_GridPrior::clear_beta() {
  beta_.Clear();
}
inline float BetaBernoulli_GridPrior::beta(int index) const {
  return beta_.Get(index);
}
inline void BetaBernoulli_GridPrior::set_beta(int index, float value) {
  beta_.Set(index, value);
}
inline void BetaBernoulli_GridPrior::add_beta(float value) {
  beta_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BetaBernoulli_GridPrior::beta() const {
  return beta_;
}
inline ::google::protobuf::RepeatedField< float >*
BetaBernoulli_GridPrior::mutable_beta() {
  return &beta_;
}

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

// BetaBernoulli_Group

// required uint64 heads = 1;
inline bool BetaBernoulli_Group::has_heads() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BetaBernoulli_Group::set_has_heads() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BetaBernoulli_Group::clear_has_heads() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BetaBernoulli_Group::clear_heads() {
  heads_ = GOOGLE_ULONGLONG(0);
  clear_has_heads();
}
inline ::google::protobuf::uint64 BetaBernoulli_Group::heads() const {
  return heads_;
}
inline void BetaBernoulli_Group::set_heads(::google::protobuf::uint64 value) {
  set_has_heads();
  heads_ = value;
}

// required uint64 tails = 2;
inline bool BetaBernoulli_Group::has_tails() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BetaBernoulli_Group::set_has_tails() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BetaBernoulli_Group::clear_has_tails() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BetaBernoulli_Group::clear_tails() {
  tails_ = GOOGLE_ULONGLONG(0);
  clear_has_tails();
}
inline ::google::protobuf::uint64 BetaBernoulli_Group::tails() const {
  return tails_;
}
inline void BetaBernoulli_Group::set_tails(::google::protobuf::uint64 value) {
  set_has_tails();
  tails_ = value;
}

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

// BetaBernoulli

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

// DirichletDiscrete_Shared

// repeated float alphas = 1;
inline int DirichletDiscrete_Shared::alphas_size() const {
  return alphas_.size();
}
inline void DirichletDiscrete_Shared::clear_alphas() {
  alphas_.Clear();
}
inline float DirichletDiscrete_Shared::alphas(int index) const {
  return alphas_.Get(index);
}
inline void DirichletDiscrete_Shared::set_alphas(int index, float value) {
  alphas_.Set(index, value);
}
inline void DirichletDiscrete_Shared::add_alphas(float value) {
  alphas_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
DirichletDiscrete_Shared::alphas() const {
  return alphas_;
}
inline ::google::protobuf::RepeatedField< float >*
DirichletDiscrete_Shared::mutable_alphas() {
  return &alphas_;
}

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

// DirichletDiscrete_GridPrior

// repeated float alpha = 1;
inline int DirichletDiscrete_GridPrior::alpha_size() const {
  return alpha_.size();
}
inline void DirichletDiscrete_GridPrior::clear_alpha() {
  alpha_.Clear();
}
inline float DirichletDiscrete_GridPrior::alpha(int index) const {
  return alpha_.Get(index);
}
inline void DirichletDiscrete_GridPrior::set_alpha(int index, float value) {
  alpha_.Set(index, value);
}
inline void DirichletDiscrete_GridPrior::add_alpha(float value) {
  alpha_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
DirichletDiscrete_GridPrior::alpha() const {
  return alpha_;
}
inline ::google::protobuf::RepeatedField< float >*
DirichletDiscrete_GridPrior::mutable_alpha() {
  return &alpha_;
}

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

// DirichletDiscrete_Group

// repeated uint64 counts = 1;
inline int DirichletDiscrete_Group::counts_size() const {
  return counts_.size();
}
inline void DirichletDiscrete_Group::clear_counts() {
  counts_.Clear();
}
inline ::google::protobuf::uint64 DirichletDiscrete_Group::counts(int index) const {
  return counts_.Get(index);
}
inline void DirichletDiscrete_Group::set_counts(int index, ::google::protobuf::uint64 value) {
  counts_.Set(index, value);
}
inline void DirichletDiscrete_Group::add_counts(::google::protobuf::uint64 value) {
  counts_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
DirichletDiscrete_Group::counts() const {
  return counts_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
DirichletDiscrete_Group::mutable_counts() {
  return &counts_;
}

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

// DirichletDiscrete

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

// DirichletProcessDiscrete_Shared

// required float gamma = 1;
inline bool DirichletProcessDiscrete_Shared::has_gamma() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DirichletProcessDiscrete_Shared::set_has_gamma() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DirichletProcessDiscrete_Shared::clear_has_gamma() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DirichletProcessDiscrete_Shared::clear_gamma() {
  gamma_ = 0;
  clear_has_gamma();
}
inline float DirichletProcessDiscrete_Shared::gamma() const {
  return gamma_;
}
inline void DirichletProcessDiscrete_Shared::set_gamma(float value) {
  set_has_gamma();
  gamma_ = value;
}

// required float alpha = 2;
inline bool DirichletProcessDiscrete_Shared::has_alpha() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DirichletProcessDiscrete_Shared::set_has_alpha() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DirichletProcessDiscrete_Shared::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DirichletProcessDiscrete_Shared::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float DirichletProcessDiscrete_Shared::alpha() const {
  return alpha_;
}
inline void DirichletProcessDiscrete_Shared::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// repeated uint32 values = 3;
inline int DirichletProcessDiscrete_Shared::values_size() const {
  return values_.size();
}
inline void DirichletProcessDiscrete_Shared::clear_values() {
  values_.Clear();
}
inline ::google::protobuf::uint32 DirichletProcessDiscrete_Shared::values(int index) const {
  return values_.Get(index);
}
inline void DirichletProcessDiscrete_Shared::set_values(int index, ::google::protobuf::uint32 value) {
  values_.Set(index, value);
}
inline void DirichletProcessDiscrete_Shared::add_values(::google::protobuf::uint32 value) {
  values_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DirichletProcessDiscrete_Shared::values() const {
  return values_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DirichletProcessDiscrete_Shared::mutable_values() {
  return &values_;
}

// repeated float betas = 4;
inline int DirichletProcessDiscrete_Shared::betas_size() const {
  return betas_.size();
}
inline void DirichletProcessDiscrete_Shared::clear_betas() {
  betas_.Clear();
}
inline float DirichletProcessDiscrete_Shared::betas(int index) const {
  return betas_.Get(index);
}
inline void DirichletProcessDiscrete_Shared::set_betas(int index, float value) {
  betas_.Set(index, value);
}
inline void DirichletProcessDiscrete_Shared::add_betas(float value) {
  betas_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
DirichletProcessDiscrete_Shared::betas() const {
  return betas_;
}
inline ::google::protobuf::RepeatedField< float >*
DirichletProcessDiscrete_Shared::mutable_betas() {
  return &betas_;
}

// repeated uint64 counts = 5;
inline int DirichletProcessDiscrete_Shared::counts_size() const {
  return counts_.size();
}
inline void DirichletProcessDiscrete_Shared::clear_counts() {
  counts_.Clear();
}
inline ::google::protobuf::uint64 DirichletProcessDiscrete_Shared::counts(int index) const {
  return counts_.Get(index);
}
inline void DirichletProcessDiscrete_Shared::set_counts(int index, ::google::protobuf::uint64 value) {
  counts_.Set(index, value);
}
inline void DirichletProcessDiscrete_Shared::add_counts(::google::protobuf::uint64 value) {
  counts_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
DirichletProcessDiscrete_Shared::counts() const {
  return counts_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
DirichletProcessDiscrete_Shared::mutable_counts() {
  return &counts_;
}

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

// DirichletProcessDiscrete_GridPrior

// repeated float gamma = 1;
inline int DirichletProcessDiscrete_GridPrior::gamma_size() const {
  return gamma_.size();
}
inline void DirichletProcessDiscrete_GridPrior::clear_gamma() {
  gamma_.Clear();
}
inline float DirichletProcessDiscrete_GridPrior::gamma(int index) const {
  return gamma_.Get(index);
}
inline void DirichletProcessDiscrete_GridPrior::set_gamma(int index, float value) {
  gamma_.Set(index, value);
}
inline void DirichletProcessDiscrete_GridPrior::add_gamma(float value) {
  gamma_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
DirichletProcessDiscrete_GridPrior::gamma() const {
  return gamma_;
}
inline ::google::protobuf::RepeatedField< float >*
DirichletProcessDiscrete_GridPrior::mutable_gamma() {
  return &gamma_;
}

// repeated float alpha = 2;
inline int DirichletProcessDiscrete_GridPrior::alpha_size() const {
  return alpha_.size();
}
inline void DirichletProcessDiscrete_GridPrior::clear_alpha() {
  alpha_.Clear();
}
inline float DirichletProcessDiscrete_GridPrior::alpha(int index) const {
  return alpha_.Get(index);
}
inline void DirichletProcessDiscrete_GridPrior::set_alpha(int index, float value) {
  alpha_.Set(index, value);
}
inline void DirichletProcessDiscrete_GridPrior::add_alpha(float value) {
  alpha_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
DirichletProcessDiscrete_GridPrior::alpha() const {
  return alpha_;
}
inline ::google::protobuf::RepeatedField< float >*
DirichletProcessDiscrete_GridPrior::mutable_alpha() {
  return &alpha_;
}

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

// DirichletProcessDiscrete_Group

// repeated uint32 keys = 1;
inline int DirichletProcessDiscrete_Group::keys_size() const {
  return keys_.size();
}
inline void DirichletProcessDiscrete_Group::clear_keys() {
  keys_.Clear();
}
inline ::google::protobuf::uint32 DirichletProcessDiscrete_Group::keys(int index) const {
  return keys_.Get(index);
}
inline void DirichletProcessDiscrete_Group::set_keys(int index, ::google::protobuf::uint32 value) {
  keys_.Set(index, value);
}
inline void DirichletProcessDiscrete_Group::add_keys(::google::protobuf::uint32 value) {
  keys_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
DirichletProcessDiscrete_Group::keys() const {
  return keys_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
DirichletProcessDiscrete_Group::mutable_keys() {
  return &keys_;
}

// repeated uint64 values = 2;
inline int DirichletProcessDiscrete_Group::values_size() const {
  return values_.size();
}
inline void DirichletProcessDiscrete_Group::clear_values() {
  values_.Clear();
}
inline ::google::protobuf::uint64 DirichletProcessDiscrete_Group::values(int index) const {
  return values_.Get(index);
}
inline void DirichletProcessDiscrete_Group::set_values(int index, ::google::protobuf::uint64 value) {
  values_.Set(index, value);
}
inline void DirichletProcessDiscrete_Group::add_values(::google::protobuf::uint64 value) {
  values_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
DirichletProcessDiscrete_Group::values() const {
  return values_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
DirichletProcessDiscrete_Group::mutable_values() {
  return &values_;
}

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

// DirichletProcessDiscrete

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

// PitmanYorProcessDiscrete_Shared

// required float alpha = 1;
inline bool PitmanYorProcessDiscrete_Shared::has_alpha() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PitmanYorProcessDiscrete_Shared::set_has_alpha() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PitmanYorProcessDiscrete_Shared::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PitmanYorProcessDiscrete_Shared::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float PitmanYorProcessDiscrete_Shared::alpha() const {
  return alpha_;
}
inline void PitmanYorProcessDiscrete_Shared::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// repeated float d = 2;
inline int PitmanYorProcessDiscrete_Shared::d_size() const {
  return d_.size();
}
inline void PitmanYorProcessDiscrete_Shared::clear_d() {
  d_.Clear();
}
inline float PitmanYorProcessDiscrete_Shared::d(int index) const {
  return d_.Get(index);
}
inline void PitmanYorProcessDiscrete_Shared::set_d(int index, float value) {
  d_.Set(index, value);
}
inline void PitmanYorProcessDiscrete_Shared::add_d(float value) {
  d_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
PitmanYorProcessDiscrete_Shared::d() const {
  return d_;
}
inline ::google::protobuf::RepeatedField< float >*
PitmanYorProcessDiscrete_Shared::mutable_d() {
  return &d_;
}

// repeated uint64 counts = 3;
inline int PitmanYorProcessDiscrete_Shared::counts_size() const {
  return counts_.size();
}
inline void PitmanYorProcessDiscrete_Shared::clear_counts() {
  counts_.Clear();
}
inline ::google::protobuf::uint64 PitmanYorProcessDiscrete_Shared::counts(int index) const {
  return counts_.Get(index);
}
inline void PitmanYorProcessDiscrete_Shared::set_counts(int index, ::google::protobuf::uint64 value) {
  counts_.Set(index, value);
}
inline void PitmanYorProcessDiscrete_Shared::add_counts(::google::protobuf::uint64 value) {
  counts_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
PitmanYorProcessDiscrete_Shared::counts() const {
  return counts_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
PitmanYorProcessDiscrete_Shared::mutable_counts() {
  return &counts_;
}

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

// PitmanYorProcessDiscrete_GridPrior

// repeated .protobuf.distributions.Clustering.PitmanYor alpha_d = 1;
inline int PitmanYorProcessDiscrete_GridPrior::alpha_d_size() const {
  return alpha_d_.size();
}
inline void PitmanYorProcessDiscrete_GridPrior::clear_alpha_d() {
  alpha_d_.Clear();
}
inline const ::protobuf::distributions::Clustering_PitmanYor& PitmanYorProcessDiscrete_GridPrior::alpha_d(int index) const {
  return alpha_d_.Get(index);
}
inline ::protobuf::distributions::Clustering_PitmanYor* PitmanYorProcessDiscrete_GridPrior::mutable_alpha_d(int index) {
  return alpha_d_.Mutable(index);
}
inline ::protobuf::distributions::Clustering_PitmanYor* PitmanYorProcessDiscrete_GridPrior::add_alpha_d() {
  return alpha_d_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf::distributions::Clustering_PitmanYor >&
PitmanYorProcessDiscrete_GridPrior::alpha_d() const {
  return alpha_d_;
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf::distributions::Clustering_PitmanYor >*
PitmanYorProcessDiscrete_GridPrior::mutable_alpha_d() {
  return &alpha_d_;
}

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

// PitmanYorProcessDiscrete_Group

// repeated uint32 keys = 1;
inline int PitmanYorProcessDiscrete_Group::keys_size() const {
  return keys_.size();
}
inline void PitmanYorProcessDiscrete_Group::clear_keys() {
  keys_.Clear();
}
inline ::google::protobuf::uint32 PitmanYorProcessDiscrete_Group::keys(int index) const {
  return keys_.Get(index);
}
inline void PitmanYorProcessDiscrete_Group::set_keys(int index, ::google::protobuf::uint32 value) {
  keys_.Set(index, value);
}
inline void PitmanYorProcessDiscrete_Group::add_keys(::google::protobuf::uint32 value) {
  keys_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
PitmanYorProcessDiscrete_Group::keys() const {
  return keys_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
PitmanYorProcessDiscrete_Group::mutable_keys() {
  return &keys_;
}

// repeated uint64 values = 2;
inline int PitmanYorProcessDiscrete_Group::values_size() const {
  return values_.size();
}
inline void PitmanYorProcessDiscrete_Group::clear_values() {
  values_.Clear();
}
inline ::google::protobuf::uint64 PitmanYorProcessDiscrete_Group::values(int index) const {
  return values_.Get(index);
}
inline void PitmanYorProcessDiscrete_Group::set_values(int index, ::google::protobuf::uint64 value) {
  values_.Set(index, value);
}
inline void PitmanYorProcessDiscrete_Group::add_values(::google::protobuf::uint64 value) {
  values_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
PitmanYorProcessDiscrete_Group::values() const {
  return values_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
PitmanYorProcessDiscrete_Group::mutable_values() {
  return &values_;
}

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

// PitmanYorProcessDiscrete

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

// GammaPoisson_Shared

// required float alpha = 1;
inline bool GammaPoisson_Shared::has_alpha() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GammaPoisson_Shared::set_has_alpha() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GammaPoisson_Shared::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GammaPoisson_Shared::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float GammaPoisson_Shared::alpha() const {
  return alpha_;
}
inline void GammaPoisson_Shared::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// required float inv_beta = 2;
inline bool GammaPoisson_Shared::has_inv_beta() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GammaPoisson_Shared::set_has_inv_beta() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GammaPoisson_Shared::clear_has_inv_beta() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GammaPoisson_Shared::clear_inv_beta() {
  inv_beta_ = 0;
  clear_has_inv_beta();
}
inline float GammaPoisson_Shared::inv_beta() const {
  return inv_beta_;
}
inline void GammaPoisson_Shared::set_inv_beta(float value) {
  set_has_inv_beta();
  inv_beta_ = value;
}

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

// GammaPoisson_GridPrior

// repeated float alpha = 1;
inline int GammaPoisson_GridPrior::alpha_size() const {
  return alpha_.size();
}
inline void GammaPoisson_GridPrior::clear_alpha() {
  alpha_.Clear();
}
inline float GammaPoisson_GridPrior::alpha(int index) const {
  return alpha_.Get(index);
}
inline void GammaPoisson_GridPrior::set_alpha(int index, float value) {
  alpha_.Set(index, value);
}
inline void GammaPoisson_GridPrior::add_alpha(float value) {
  alpha_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
GammaPoisson_GridPrior::alpha() const {
  return alpha_;
}
inline ::google::protobuf::RepeatedField< float >*
GammaPoisson_GridPrior::mutable_alpha() {
  return &alpha_;
}

// repeated float inv_beta = 2;
inline int GammaPoisson_GridPrior::inv_beta_size() const {
  return inv_beta_.size();
}
inline void GammaPoisson_GridPrior::clear_inv_beta() {
  inv_beta_.Clear();
}
inline float GammaPoisson_GridPrior::inv_beta(int index) const {
  return inv_beta_.Get(index);
}
inline void GammaPoisson_GridPrior::set_inv_beta(int index, float value) {
  inv_beta_.Set(index, value);
}
inline void GammaPoisson_GridPrior::add_inv_beta(float value) {
  inv_beta_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
GammaPoisson_GridPrior::inv_beta() const {
  return inv_beta_;
}
inline ::google::protobuf::RepeatedField< float >*
GammaPoisson_GridPrior::mutable_inv_beta() {
  return &inv_beta_;
}

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

// GammaPoisson_Group

// required uint64 count = 1;
inline bool GammaPoisson_Group::has_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GammaPoisson_Group::set_has_count() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GammaPoisson_Group::clear_has_count() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GammaPoisson_Group::clear_count() {
  count_ = GOOGLE_ULONGLONG(0);
  clear_has_count();
}
inline ::google::protobuf::uint64 GammaPoisson_Group::count() const {
  return count_;
}
inline void GammaPoisson_Group::set_count(::google::protobuf::uint64 value) {
  set_has_count();
  count_ = value;
}

// required uint64 sum = 2;
inline bool GammaPoisson_Group::has_sum() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GammaPoisson_Group::set_has_sum() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GammaPoisson_Group::clear_has_sum() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GammaPoisson_Group::clear_sum() {
  sum_ = GOOGLE_ULONGLONG(0);
  clear_has_sum();
}
inline ::google::protobuf::uint64 GammaPoisson_Group::sum() const {
  return sum_;
}
inline void GammaPoisson_Group::set_sum(::google::protobuf::uint64 value) {
  set_has_sum();
  sum_ = value;
}

// required float log_prod = 3;
inline bool GammaPoisson_Group::has_log_prod() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GammaPoisson_Group::set_has_log_prod() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GammaPoisson_Group::clear_has_log_prod() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GammaPoisson_Group::clear_log_prod() {
  log_prod_ = 0;
  clear_has_log_prod();
}
inline float GammaPoisson_Group::log_prod() const {
  return log_prod_;
}
inline void GammaPoisson_Group::set_log_prod(float value) {
  set_has_log_prod();
  log_prod_ = value;
}

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

// GammaPoisson

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

// BetaNegativeBinomial_Shared

// required float alpha = 1;
inline bool BetaNegativeBinomial_Shared::has_alpha() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BetaNegativeBinomial_Shared::set_has_alpha() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BetaNegativeBinomial_Shared::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BetaNegativeBinomial_Shared::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float BetaNegativeBinomial_Shared::alpha() const {
  return alpha_;
}
inline void BetaNegativeBinomial_Shared::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// required float beta = 2;
inline bool BetaNegativeBinomial_Shared::has_beta() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BetaNegativeBinomial_Shared::set_has_beta() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BetaNegativeBinomial_Shared::clear_has_beta() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BetaNegativeBinomial_Shared::clear_beta() {
  beta_ = 0;
  clear_has_beta();
}
inline float BetaNegativeBinomial_Shared::beta() const {
  return beta_;
}
inline void BetaNegativeBinomial_Shared::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

// required uint64 r = 3;
inline bool BetaNegativeBinomial_Shared::has_r() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BetaNegativeBinomial_Shared::set_has_r() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BetaNegativeBinomial_Shared::clear_has_r() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BetaNegativeBinomial_Shared::clear_r() {
  r_ = GOOGLE_ULONGLONG(0);
  clear_has_r();
}
inline ::google::protobuf::uint64 BetaNegativeBinomial_Shared::r() const {
  return r_;
}
inline void BetaNegativeBinomial_Shared::set_r(::google::protobuf::uint64 value) {
  set_has_r();
  r_ = value;
}

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

// BetaNegativeBinomial_GridPrior

// repeated float alpha = 1;
inline int BetaNegativeBinomial_GridPrior::alpha_size() const {
  return alpha_.size();
}
inline void BetaNegativeBinomial_GridPrior::clear_alpha() {
  alpha_.Clear();
}
inline float BetaNegativeBinomial_GridPrior::alpha(int index) const {
  return alpha_.Get(index);
}
inline void BetaNegativeBinomial_GridPrior::set_alpha(int index, float value) {
  alpha_.Set(index, value);
}
inline void BetaNegativeBinomial_GridPrior::add_alpha(float value) {
  alpha_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BetaNegativeBinomial_GridPrior::alpha() const {
  return alpha_;
}
inline ::google::protobuf::RepeatedField< float >*
BetaNegativeBinomial_GridPrior::mutable_alpha() {
  return &alpha_;
}

// repeated float beta = 2;
inline int BetaNegativeBinomial_GridPrior::beta_size() const {
  return beta_.size();
}
inline void BetaNegativeBinomial_GridPrior::clear_beta() {
  beta_.Clear();
}
inline float BetaNegativeBinomial_GridPrior::beta(int index) const {
  return beta_.Get(index);
}
inline void BetaNegativeBinomial_GridPrior::set_beta(int index, float value) {
  beta_.Set(index, value);
}
inline void BetaNegativeBinomial_GridPrior::add_beta(float value) {
  beta_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
BetaNegativeBinomial_GridPrior::beta() const {
  return beta_;
}
inline ::google::protobuf::RepeatedField< float >*
BetaNegativeBinomial_GridPrior::mutable_beta() {
  return &beta_;
}

// repeated uint64 r = 3;
inline int BetaNegativeBinomial_GridPrior::r_size() const {
  return r_.size();
}
inline void BetaNegativeBinomial_GridPrior::clear_r() {
  r_.Clear();
}
inline ::google::protobuf::uint64 BetaNegativeBinomial_GridPrior::r(int index) const {
  return r_.Get(index);
}
inline void BetaNegativeBinomial_GridPrior::set_r(int index, ::google::protobuf::uint64 value) {
  r_.Set(index, value);
}
inline void BetaNegativeBinomial_GridPrior::add_r(::google::protobuf::uint64 value) {
  r_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
BetaNegativeBinomial_GridPrior::r() const {
  return r_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
BetaNegativeBinomial_GridPrior::mutable_r() {
  return &r_;
}

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

// BetaNegativeBinomial_Group

// required uint64 count = 1;
inline bool BetaNegativeBinomial_Group::has_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BetaNegativeBinomial_Group::set_has_count() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BetaNegativeBinomial_Group::clear_has_count() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BetaNegativeBinomial_Group::clear_count() {
  count_ = GOOGLE_ULONGLONG(0);
  clear_has_count();
}
inline ::google::protobuf::uint64 BetaNegativeBinomial_Group::count() const {
  return count_;
}
inline void BetaNegativeBinomial_Group::set_count(::google::protobuf::uint64 value) {
  set_has_count();
  count_ = value;
}

// required uint64 sum = 2;
inline bool BetaNegativeBinomial_Group::has_sum() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BetaNegativeBinomial_Group::set_has_sum() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BetaNegativeBinomial_Group::clear_has_sum() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BetaNegativeBinomial_Group::clear_sum() {
  sum_ = GOOGLE_ULONGLONG(0);
  clear_has_sum();
}
inline ::google::protobuf::uint64 BetaNegativeBinomial_Group::sum() const {
  return sum_;
}
inline void BetaNegativeBinomial_Group::set_sum(::google::protobuf::uint64 value) {
  set_has_sum();
  sum_ = value;
}

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

// BetaNegativeBinomial

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

// NormalInverseChiSq_Shared

// required float mu = 1;
inline bool NormalInverseChiSq_Shared::has_mu() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NormalInverseChiSq_Shared::set_has_mu() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NormalInverseChiSq_Shared::clear_has_mu() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NormalInverseChiSq_Shared::clear_mu() {
  mu_ = 0;
  clear_has_mu();
}
inline float NormalInverseChiSq_Shared::mu() const {
  return mu_;
}
inline void NormalInverseChiSq_Shared::set_mu(float value) {
  set_has_mu();
  mu_ = value;
}

// required float kappa = 2;
inline bool NormalInverseChiSq_Shared::has_kappa() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NormalInverseChiSq_Shared::set_has_kappa() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NormalInverseChiSq_Shared::clear_has_kappa() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NormalInverseChiSq_Shared::clear_kappa() {
  kappa_ = 0;
  clear_has_kappa();
}
inline float NormalInverseChiSq_Shared::kappa() const {
  return kappa_;
}
inline void NormalInverseChiSq_Shared::set_kappa(float value) {
  set_has_kappa();
  kappa_ = value;
}

// required float sigmasq = 3;
inline bool NormalInverseChiSq_Shared::has_sigmasq() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NormalInverseChiSq_Shared::set_has_sigmasq() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NormalInverseChiSq_Shared::clear_has_sigmasq() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NormalInverseChiSq_Shared::clear_sigmasq() {
  sigmasq_ = 0;
  clear_has_sigmasq();
}
inline float NormalInverseChiSq_Shared::sigmasq() const {
  return sigmasq_;
}
inline void NormalInverseChiSq_Shared::set_sigmasq(float value) {
  set_has_sigmasq();
  sigmasq_ = value;
}

// required float nu = 4;
inline bool NormalInverseChiSq_Shared::has_nu() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NormalInverseChiSq_Shared::set_has_nu() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NormalInverseChiSq_Shared::clear_has_nu() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NormalInverseChiSq_Shared::clear_nu() {
  nu_ = 0;
  clear_has_nu();
}
inline float NormalInverseChiSq_Shared::nu() const {
  return nu_;
}
inline void NormalInverseChiSq_Shared::set_nu(float value) {
  set_has_nu();
  nu_ = value;
}

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

// NormalInverseChiSq_GridPrior

// repeated float mu = 1;
inline int NormalInverseChiSq_GridPrior::mu_size() const {
  return mu_.size();
}
inline void NormalInverseChiSq_GridPrior::clear_mu() {
  mu_.Clear();
}
inline float NormalInverseChiSq_GridPrior::mu(int index) const {
  return mu_.Get(index);
}
inline void NormalInverseChiSq_GridPrior::set_mu(int index, float value) {
  mu_.Set(index, value);
}
inline void NormalInverseChiSq_GridPrior::add_mu(float value) {
  mu_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
NormalInverseChiSq_GridPrior::mu() const {
  return mu_;
}
inline ::google::protobuf::RepeatedField< float >*
NormalInverseChiSq_GridPrior::mutable_mu() {
  return &mu_;
}

// repeated float kappa = 2;
inline int NormalInverseChiSq_GridPrior::kappa_size() const {
  return kappa_.size();
}
inline void NormalInverseChiSq_GridPrior::clear_kappa() {
  kappa_.Clear();
}
inline float NormalInverseChiSq_GridPrior::kappa(int index) const {
  return kappa_.Get(index);
}
inline void NormalInverseChiSq_GridPrior::set_kappa(int index, float value) {
  kappa_.Set(index, value);
}
inline void NormalInverseChiSq_GridPrior::add_kappa(float value) {
  kappa_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
NormalInverseChiSq_GridPrior::kappa() const {
  return kappa_;
}
inline ::google::protobuf::RepeatedField< float >*
NormalInverseChiSq_GridPrior::mutable_kappa() {
  return &kappa_;
}

// repeated float sigmasq = 3;
inline int NormalInverseChiSq_GridPrior::sigmasq_size() const {
  return sigmasq_.size();
}
inline void NormalInverseChiSq_GridPrior::clear_sigmasq() {
  sigmasq_.Clear();
}
inline float NormalInverseChiSq_GridPrior::sigmasq(int index) const {
  return sigmasq_.Get(index);
}
inline void NormalInverseChiSq_GridPrior::set_sigmasq(int index, float value) {
  sigmasq_.Set(index, value);
}
inline void NormalInverseChiSq_GridPrior::add_sigmasq(float value) {
  sigmasq_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
NormalInverseChiSq_GridPrior::sigmasq() const {
  return sigmasq_;
}
inline ::google::protobuf::RepeatedField< float >*
NormalInverseChiSq_GridPrior::mutable_sigmasq() {
  return &sigmasq_;
}

// repeated float nu = 4;
inline int NormalInverseChiSq_GridPrior::nu_size() const {
  return nu_.size();
}
inline void NormalInverseChiSq_GridPrior::clear_nu() {
  nu_.Clear();
}
inline float NormalInverseChiSq_GridPrior::nu(int index) const {
  return nu_.Get(index);
}
inline void NormalInverseChiSq_GridPrior::set_nu(int index, float value) {
  nu_.Set(index, value);
}
inline void NormalInverseChiSq_GridPrior::add_nu(float value) {
  nu_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
NormalInverseChiSq_GridPrior::nu() const {
  return nu_;
}
inline ::google::protobuf::RepeatedField< float >*
NormalInverseChiSq_GridPrior::mutable_nu() {
  return &nu_;
}

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

// NormalInverseChiSq_Group

// required uint64 count = 1;
inline bool NormalInverseChiSq_Group::has_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NormalInverseChiSq_Group::set_has_count() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NormalInverseChiSq_Group::clear_has_count() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NormalInverseChiSq_Group::clear_count() {
  count_ = GOOGLE_ULONGLONG(0);
  clear_has_count();
}
inline ::google::protobuf::uint64 NormalInverseChiSq_Group::count() const {
  return count_;
}
inline void NormalInverseChiSq_Group::set_count(::google::protobuf::uint64 value) {
  set_has_count();
  count_ = value;
}

// required float mean = 2;
inline bool NormalInverseChiSq_Group::has_mean() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NormalInverseChiSq_Group::set_has_mean() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NormalInverseChiSq_Group::clear_has_mean() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NormalInverseChiSq_Group::clear_mean() {
  mean_ = 0;
  clear_has_mean();
}
inline float NormalInverseChiSq_Group::mean() const {
  return mean_;
}
inline void NormalInverseChiSq_Group::set_mean(float value) {
  set_has_mean();
  mean_ = value;
}

// required float count_times_variance = 3;
inline bool NormalInverseChiSq_Group::has_count_times_variance() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NormalInverseChiSq_Group::set_has_count_times_variance() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NormalInverseChiSq_Group::clear_has_count_times_variance() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NormalInverseChiSq_Group::clear_count_times_variance() {
  count_times_variance_ = 0;
  clear_has_count_times_variance();
}
inline float NormalInverseChiSq_Group::count_times_variance() const {
  return count_times_variance_;
}
inline void NormalInverseChiSq_Group::set_count_times_variance(float value) {
  set_has_count_times_variance();
  count_times_variance_ = value;
}

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

// NormalInverseChiSq


// @@protoc_insertion_point(namespace_scope)

}  // namespace distributions
}  // namespace protobuf

#ifndef SWIG
namespace google {
namespace protobuf {


}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_distributions_2fio_2fschema_2eproto__INCLUDED
