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

#ifndef GOOGLE_PROTOBUF_INCLUDED_GatingSet_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_GatingSet_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_GatingSet_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[33]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_GatingSet_2eproto;
namespace pb {
class BOOL_GATE_OP;
class BOOL_GATE_OPDefaultTypeInternal;
extern BOOL_GATE_OPDefaultTypeInternal _BOOL_GATE_OP_default_instance_;
class COMP;
class COMPDefaultTypeInternal;
extern COMPDefaultTypeInternal _COMP_default_instance_;
class CytoFrame;
class CytoFrameDefaultTypeInternal;
extern CytoFrameDefaultTypeInternal _CytoFrame_default_instance_;
class GatingHierarchy;
class GatingHierarchyDefaultTypeInternal;
extern GatingHierarchyDefaultTypeInternal _GatingHierarchy_default_instance_;
class GatingSet;
class GatingSetDefaultTypeInternal;
extern GatingSetDefaultTypeInternal _GatingSet_default_instance_;
class PARAM;
class PARAMDefaultTypeInternal;
extern PARAMDefaultTypeInternal _PARAM_default_instance_;
class POPINDICES;
class POPINDICESDefaultTypeInternal;
extern POPINDICESDefaultTypeInternal _POPINDICES_default_instance_;
class POPSTATS;
class POPSTATSDefaultTypeInternal;
extern POPSTATSDefaultTypeInternal _POPSTATS_default_instance_;
class TRANS_TBL;
class TRANS_TBLDefaultTypeInternal;
extern TRANS_TBLDefaultTypeInternal _TRANS_TBL_default_instance_;
class biexpTrans;
class biexpTransDefaultTypeInternal;
extern biexpTransDefaultTypeInternal _biexpTrans_default_instance_;
class boolGate;
class boolGateDefaultTypeInternal;
extern boolGateDefaultTypeInternal _boolGate_default_instance_;
class calibrationTable;
class calibrationTableDefaultTypeInternal;
extern calibrationTableDefaultTypeInternal _calibrationTable_default_instance_;
class clusterGate;
class clusterGateDefaultTypeInternal;
extern clusterGateDefaultTypeInternal _clusterGate_default_instance_;
class coordinate;
class coordinateDefaultTypeInternal;
extern coordinateDefaultTypeInternal _coordinate_default_instance_;
class ellipseGate;
class ellipseGateDefaultTypeInternal;
extern ellipseGateDefaultTypeInternal _ellipseGate_default_instance_;
class fasinhTrans;
class fasinhTransDefaultTypeInternal;
extern fasinhTransDefaultTypeInternal _fasinhTrans_default_instance_;
class flinTrans;
class flinTransDefaultTypeInternal;
extern flinTransDefaultTypeInternal _flinTrans_default_instance_;
class gate;
class gateDefaultTypeInternal;
extern gateDefaultTypeInternal _gate_default_instance_;
class logGML2Trans;
class logGML2TransDefaultTypeInternal;
extern logGML2TransDefaultTypeInternal _logGML2Trans_default_instance_;
class logTrans;
class logTransDefaultTypeInternal;
extern logTransDefaultTypeInternal _logTrans_default_instance_;
class logicleTrans;
class logicleTransDefaultTypeInternal;
extern logicleTransDefaultTypeInternal _logicleTrans_default_instance_;
class nodeProperties;
class nodePropertiesDefaultTypeInternal;
extern nodePropertiesDefaultTypeInternal _nodeProperties_default_instance_;
class paramPoly;
class paramPolyDefaultTypeInternal;
extern paramPolyDefaultTypeInternal _paramPoly_default_instance_;
class paramRange;
class paramRangeDefaultTypeInternal;
extern paramRangeDefaultTypeInternal _paramRange_default_instance_;
class polygonGate;
class polygonGateDefaultTypeInternal;
extern polygonGateDefaultTypeInternal _polygonGate_default_instance_;
class populationTree;
class populationTreeDefaultTypeInternal;
extern populationTreeDefaultTypeInternal _populationTree_default_instance_;
class quadGate;
class quadGateDefaultTypeInternal;
extern quadGateDefaultTypeInternal _quadGate_default_instance_;
class rangeGate;
class rangeGateDefaultTypeInternal;
extern rangeGateDefaultTypeInternal _rangeGate_default_instance_;
class scaleTrans;
class scaleTransDefaultTypeInternal;
extern scaleTransDefaultTypeInternal _scaleTrans_default_instance_;
class trans_local;
class trans_localDefaultTypeInternal;
extern trans_localDefaultTypeInternal _trans_local_default_instance_;
class trans_pair;
class trans_pairDefaultTypeInternal;
extern trans_pairDefaultTypeInternal _trans_pair_default_instance_;
class transformation;
class transformationDefaultTypeInternal;
extern transformationDefaultTypeInternal _transformation_default_instance_;
class treeNodes;
class treeNodesDefaultTypeInternal;
extern treeNodesDefaultTypeInternal _treeNodes_default_instance_;
}  // namespace pb
PROTOBUF_NAMESPACE_OPEN
template<> ::pb::BOOL_GATE_OP* Arena::CreateMaybeMessage<::pb::BOOL_GATE_OP>(Arena*);
template<> ::pb::COMP* Arena::CreateMaybeMessage<::pb::COMP>(Arena*);
template<> ::pb::CytoFrame* Arena::CreateMaybeMessage<::pb::CytoFrame>(Arena*);
template<> ::pb::GatingHierarchy* Arena::CreateMaybeMessage<::pb::GatingHierarchy>(Arena*);
template<> ::pb::GatingSet* Arena::CreateMaybeMessage<::pb::GatingSet>(Arena*);
template<> ::pb::PARAM* Arena::CreateMaybeMessage<::pb::PARAM>(Arena*);
template<> ::pb::POPINDICES* Arena::CreateMaybeMessage<::pb::POPINDICES>(Arena*);
template<> ::pb::POPSTATS* Arena::CreateMaybeMessage<::pb::POPSTATS>(Arena*);
template<> ::pb::TRANS_TBL* Arena::CreateMaybeMessage<::pb::TRANS_TBL>(Arena*);
template<> ::pb::biexpTrans* Arena::CreateMaybeMessage<::pb::biexpTrans>(Arena*);
template<> ::pb::boolGate* Arena::CreateMaybeMessage<::pb::boolGate>(Arena*);
template<> ::pb::calibrationTable* Arena::CreateMaybeMessage<::pb::calibrationTable>(Arena*);
template<> ::pb::clusterGate* Arena::CreateMaybeMessage<::pb::clusterGate>(Arena*);
template<> ::pb::coordinate* Arena::CreateMaybeMessage<::pb::coordinate>(Arena*);
template<> ::pb::ellipseGate* Arena::CreateMaybeMessage<::pb::ellipseGate>(Arena*);
template<> ::pb::fasinhTrans* Arena::CreateMaybeMessage<::pb::fasinhTrans>(Arena*);
template<> ::pb::flinTrans* Arena::CreateMaybeMessage<::pb::flinTrans>(Arena*);
template<> ::pb::gate* Arena::CreateMaybeMessage<::pb::gate>(Arena*);
template<> ::pb::logGML2Trans* Arena::CreateMaybeMessage<::pb::logGML2Trans>(Arena*);
template<> ::pb::logTrans* Arena::CreateMaybeMessage<::pb::logTrans>(Arena*);
template<> ::pb::logicleTrans* Arena::CreateMaybeMessage<::pb::logicleTrans>(Arena*);
template<> ::pb::nodeProperties* Arena::CreateMaybeMessage<::pb::nodeProperties>(Arena*);
template<> ::pb::paramPoly* Arena::CreateMaybeMessage<::pb::paramPoly>(Arena*);
template<> ::pb::paramRange* Arena::CreateMaybeMessage<::pb::paramRange>(Arena*);
template<> ::pb::polygonGate* Arena::CreateMaybeMessage<::pb::polygonGate>(Arena*);
template<> ::pb::populationTree* Arena::CreateMaybeMessage<::pb::populationTree>(Arena*);
template<> ::pb::quadGate* Arena::CreateMaybeMessage<::pb::quadGate>(Arena*);
template<> ::pb::rangeGate* Arena::CreateMaybeMessage<::pb::rangeGate>(Arena*);
template<> ::pb::scaleTrans* Arena::CreateMaybeMessage<::pb::scaleTrans>(Arena*);
template<> ::pb::trans_local* Arena::CreateMaybeMessage<::pb::trans_local>(Arena*);
template<> ::pb::trans_pair* Arena::CreateMaybeMessage<::pb::trans_pair>(Arena*);
template<> ::pb::transformation* Arena::CreateMaybeMessage<::pb::transformation>(Arena*);
template<> ::pb::treeNodes* Arena::CreateMaybeMessage<::pb::treeNodes>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace pb {

enum QUADRANT : int {
  Q_UNSPECIFIED = 0,
  Q1 = 1,
  Q2 = 2,
  Q3 = 3,
  Q4 = 4,
  QUADRANT_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  QUADRANT_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool QUADRANT_IsValid(int value);
constexpr QUADRANT QUADRANT_MIN = Q_UNSPECIFIED;
constexpr QUADRANT QUADRANT_MAX = Q4;
constexpr int QUADRANT_ARRAYSIZE = QUADRANT_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QUADRANT_descriptor();
template<typename T>
inline const std::string& QUADRANT_Name(T enum_t_value) {
  static_assert(::std::is_same<T, QUADRANT>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function QUADRANT_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    QUADRANT_descriptor(), enum_t_value);
}
inline bool QUADRANT_Parse(
    const std::string& name, QUADRANT* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<QUADRANT>(
    QUADRANT_descriptor(), name, value);
}
enum GATE_TYPE : int {
  GATE_UNSPECIFIED = 0,
  POLYGON_GATE = 1,
  RANGE_GATE = 2,
  BOOL_GATE = 3,
  ELLIPSE_GATE = 4,
  RECT_GATE = 5,
  LOGICAL_GATE = 6,
  ELLIPSOID_GATE = 7,
  CLUSTER_GATE = 8,
  QUAD_GATE = 9,
  GATE_TYPE_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  GATE_TYPE_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool GATE_TYPE_IsValid(int value);
constexpr GATE_TYPE GATE_TYPE_MIN = GATE_UNSPECIFIED;
constexpr GATE_TYPE GATE_TYPE_MAX = QUAD_GATE;
constexpr int GATE_TYPE_ARRAYSIZE = GATE_TYPE_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GATE_TYPE_descriptor();
template<typename T>
inline const std::string& GATE_TYPE_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GATE_TYPE>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GATE_TYPE_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    GATE_TYPE_descriptor(), enum_t_value);
}
inline bool GATE_TYPE_Parse(
    const std::string& name, GATE_TYPE* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GATE_TYPE>(
    GATE_TYPE_descriptor(), name, value);
}
enum ind_type : int {
  BOOL = 0,
  INT = 1,
  ROOT = 2,
  ind_type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ind_type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ind_type_IsValid(int value);
constexpr ind_type ind_type_MIN = BOOL;
constexpr ind_type ind_type_MAX = ROOT;
constexpr int ind_type_ARRAYSIZE = ind_type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ind_type_descriptor();
template<typename T>
inline const std::string& ind_type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ind_type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ind_type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ind_type_descriptor(), enum_t_value);
}
inline bool ind_type_Parse(
    const std::string& name, ind_type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ind_type>(
    ind_type_descriptor(), name, value);
}
enum TRANS_TYPE : int {
  PB_CALTBL = 0,
  PB_LOG = 1,
  PB_LIN = 2,
  PB_FLIN = 3,
  PB_FASIGNH = 4,
  PB_BIEXP = 5,
  PB_LOGICLE = 6,
  PB_LOGGML2 = 7,
  PB_SCALE = 8,
  TRANS_TYPE_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  TRANS_TYPE_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool TRANS_TYPE_IsValid(int value);
constexpr TRANS_TYPE TRANS_TYPE_MIN = PB_CALTBL;
constexpr TRANS_TYPE TRANS_TYPE_MAX = PB_SCALE;
constexpr int TRANS_TYPE_ARRAYSIZE = TRANS_TYPE_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TRANS_TYPE_descriptor();
template<typename T>
inline const std::string& TRANS_TYPE_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TRANS_TYPE>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TRANS_TYPE_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TRANS_TYPE_descriptor(), enum_t_value);
}
inline bool TRANS_TYPE_Parse(
    const std::string& name, TRANS_TYPE* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TRANS_TYPE>(
    TRANS_TYPE_descriptor(), name, value);
}
// ===================================================================

class paramRange :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.paramRange) */ {
 public:
  paramRange();
  virtual ~paramRange();

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

  inline paramRange& operator=(const paramRange& from) {
    CopyFrom(from);
    return *this;
  }
  inline paramRange& operator=(paramRange&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const paramRange& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const paramRange* internal_default_instance() {
    return reinterpret_cast<const paramRange*>(
               &_paramRange_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(paramRange* other);
  friend void swap(paramRange& a, paramRange& b) {
    a.Swap(&b);
  }

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

  inline paramRange* New() const final {
    return CreateMaybeMessage<paramRange>(nullptr);
  }

  paramRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<paramRange>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const paramRange& from);
  void MergeFrom(const paramRange& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(paramRange* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.paramRange";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // float min = 2;
  void clear_min();
  static const int kMinFieldNumber = 2;
  float min() const;
  void set_min(float value);

  // float max = 3;
  void clear_max();
  static const int kMaxFieldNumber = 3;
  float max() const;
  void set_max(float value);

  // @@protoc_insertion_point(class_scope:pb.paramRange)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  float min_;
  float max_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class rangeGate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.rangeGate) */ {
 public:
  rangeGate();
  virtual ~rangeGate();

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

  inline rangeGate& operator=(const rangeGate& from) {
    CopyFrom(from);
    return *this;
  }
  inline rangeGate& operator=(rangeGate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const rangeGate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const rangeGate* internal_default_instance() {
    return reinterpret_cast<const rangeGate*>(
               &_rangeGate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(rangeGate* other);
  friend void swap(rangeGate& a, rangeGate& b) {
    a.Swap(&b);
  }

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

  inline rangeGate* New() const final {
    return CreateMaybeMessage<rangeGate>(nullptr);
  }

  rangeGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<rangeGate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const rangeGate& from);
  void MergeFrom(const rangeGate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(rangeGate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.rangeGate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // .pb.paramRange param = 1;
  bool has_param() const;
  void clear_param();
  static const int kParamFieldNumber = 1;
  const ::pb::paramRange& param() const;
  ::pb::paramRange* release_param();
  ::pb::paramRange* mutable_param();
  void set_allocated_param(::pb::paramRange* param);

  // @@protoc_insertion_point(class_scope:pb.rangeGate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::pb::paramRange* param_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class paramPoly :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.paramPoly) */ {
 public:
  paramPoly();
  virtual ~paramPoly();

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

  inline paramPoly& operator=(const paramPoly& from) {
    CopyFrom(from);
    return *this;
  }
  inline paramPoly& operator=(paramPoly&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const paramPoly& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const paramPoly* internal_default_instance() {
    return reinterpret_cast<const paramPoly*>(
               &_paramPoly_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(paramPoly* other);
  friend void swap(paramPoly& a, paramPoly& b) {
    a.Swap(&b);
  }

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

  inline paramPoly* New() const final {
    return CreateMaybeMessage<paramPoly>(nullptr);
  }

  paramPoly* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<paramPoly>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const paramPoly& from);
  void MergeFrom(const paramPoly& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(paramPoly* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.paramPoly";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated string params = 1;
  int params_size() const;
  void clear_params();
  static const int kParamsFieldNumber = 1;
  const std::string& params(int index) const;
  std::string* mutable_params(int index);
  void set_params(int index, const std::string& value);
  void set_params(int index, std::string&& value);
  void set_params(int index, const char* value);
  void set_params(int index, const char* value, size_t size);
  std::string* add_params();
  void add_params(const std::string& value);
  void add_params(std::string&& value);
  void add_params(const char* value);
  void add_params(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& params() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_params();

  // repeated .pb.coordinate vertices = 2;
  int vertices_size() const;
  void clear_vertices();
  static const int kVerticesFieldNumber = 2;
  ::pb::coordinate* mutable_vertices(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >*
      mutable_vertices();
  const ::pb::coordinate& vertices(int index) const;
  ::pb::coordinate* add_vertices();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >&
      vertices() const;

  // @@protoc_insertion_point(class_scope:pb.paramPoly)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> params_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate > vertices_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class polygonGate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.polygonGate) */ {
 public:
  polygonGate();
  virtual ~polygonGate();

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

  inline polygonGate& operator=(const polygonGate& from) {
    CopyFrom(from);
    return *this;
  }
  inline polygonGate& operator=(polygonGate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const polygonGate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const polygonGate* internal_default_instance() {
    return reinterpret_cast<const polygonGate*>(
               &_polygonGate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(polygonGate* other);
  friend void swap(polygonGate& a, polygonGate& b) {
    a.Swap(&b);
  }

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

  inline polygonGate* New() const final {
    return CreateMaybeMessage<polygonGate>(nullptr);
  }

  polygonGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<polygonGate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const polygonGate& from);
  void MergeFrom(const polygonGate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(polygonGate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.polygonGate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // .pb.paramPoly param = 1;
  bool has_param() const;
  void clear_param();
  static const int kParamFieldNumber = 1;
  const ::pb::paramPoly& param() const;
  ::pb::paramPoly* release_param();
  ::pb::paramPoly* mutable_param();
  void set_allocated_param(::pb::paramPoly* param);

  // .pb.quadGate qg = 2;
  bool has_qg() const;
  void clear_qg();
  static const int kQgFieldNumber = 2;
  const ::pb::quadGate& qg() const;
  ::pb::quadGate* release_qg();
  ::pb::quadGate* mutable_qg();
  void set_allocated_qg(::pb::quadGate* qg);

  // @@protoc_insertion_point(class_scope:pb.polygonGate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::pb::paramPoly* param_;
  ::pb::quadGate* qg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class coordinate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.coordinate) */ {
 public:
  coordinate();
  virtual ~coordinate();

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

  inline coordinate& operator=(const coordinate& from) {
    CopyFrom(from);
    return *this;
  }
  inline coordinate& operator=(coordinate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const coordinate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const coordinate* internal_default_instance() {
    return reinterpret_cast<const coordinate*>(
               &_coordinate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(coordinate* other);
  friend void swap(coordinate& a, coordinate& b) {
    a.Swap(&b);
  }

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

  inline coordinate* New() const final {
    return CreateMaybeMessage<coordinate>(nullptr);
  }

  coordinate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<coordinate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const coordinate& from);
  void MergeFrom(const coordinate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(coordinate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.coordinate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float x = 1;
  void clear_x();
  static const int kXFieldNumber = 1;
  float x() const;
  void set_x(float value);

  // float y = 2;
  void clear_y();
  static const int kYFieldNumber = 2;
  float y() const;
  void set_y(float value);

  // @@protoc_insertion_point(class_scope:pb.coordinate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float x_;
  float y_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class ellipseGate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.ellipseGate) */ {
 public:
  ellipseGate();
  virtual ~ellipseGate();

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

  inline ellipseGate& operator=(const ellipseGate& from) {
    CopyFrom(from);
    return *this;
  }
  inline ellipseGate& operator=(ellipseGate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ellipseGate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ellipseGate* internal_default_instance() {
    return reinterpret_cast<const ellipseGate*>(
               &_ellipseGate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(ellipseGate* other);
  friend void swap(ellipseGate& a, ellipseGate& b) {
    a.Swap(&b);
  }

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

  inline ellipseGate* New() const final {
    return CreateMaybeMessage<ellipseGate>(nullptr);
  }

  ellipseGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ellipseGate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ellipseGate& from);
  void MergeFrom(const ellipseGate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ellipseGate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.ellipseGate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated .pb.coordinate cov = 2;
  int cov_size() const;
  void clear_cov();
  static const int kCovFieldNumber = 2;
  ::pb::coordinate* mutable_cov(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >*
      mutable_cov();
  const ::pb::coordinate& cov(int index) const;
  ::pb::coordinate* add_cov();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >&
      cov() const;

  // repeated .pb.coordinate antipodal_vertices = 3;
  int antipodal_vertices_size() const;
  void clear_antipodal_vertices();
  static const int kAntipodalVerticesFieldNumber = 3;
  ::pb::coordinate* mutable_antipodal_vertices(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >*
      mutable_antipodal_vertices();
  const ::pb::coordinate& antipodal_vertices(int index) const;
  ::pb::coordinate* add_antipodal_vertices();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >&
      antipodal_vertices() const;

  // .pb.coordinate mu = 1;
  bool has_mu() const;
  void clear_mu();
  static const int kMuFieldNumber = 1;
  const ::pb::coordinate& mu() const;
  ::pb::coordinate* release_mu();
  ::pb::coordinate* mutable_mu();
  void set_allocated_mu(::pb::coordinate* mu);

  // float dist = 4;
  void clear_dist();
  static const int kDistFieldNumber = 4;
  float dist() const;
  void set_dist(float value);

  // @@protoc_insertion_point(class_scope:pb.ellipseGate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate > cov_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate > antipodal_vertices_;
  ::pb::coordinate* mu_;
  float dist_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class BOOL_GATE_OP :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.BOOL_GATE_OP) */ {
 public:
  BOOL_GATE_OP();
  virtual ~BOOL_GATE_OP();

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

  inline BOOL_GATE_OP& operator=(const BOOL_GATE_OP& from) {
    CopyFrom(from);
    return *this;
  }
  inline BOOL_GATE_OP& operator=(BOOL_GATE_OP&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BOOL_GATE_OP& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BOOL_GATE_OP* internal_default_instance() {
    return reinterpret_cast<const BOOL_GATE_OP*>(
               &_BOOL_GATE_OP_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(BOOL_GATE_OP* other);
  friend void swap(BOOL_GATE_OP& a, BOOL_GATE_OP& b) {
    a.Swap(&b);
  }

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

  inline BOOL_GATE_OP* New() const final {
    return CreateMaybeMessage<BOOL_GATE_OP>(nullptr);
  }

  BOOL_GATE_OP* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BOOL_GATE_OP>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BOOL_GATE_OP& from);
  void MergeFrom(const BOOL_GATE_OP& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BOOL_GATE_OP* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.BOOL_GATE_OP";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated string path = 1;
  int path_size() const;
  void clear_path();
  static const int kPathFieldNumber = 1;
  const std::string& path(int index) const;
  std::string* mutable_path(int index);
  void set_path(int index, const std::string& value);
  void set_path(int index, std::string&& value);
  void set_path(int index, const char* value);
  void set_path(int index, const char* value, size_t size);
  std::string* add_path();
  void add_path(const std::string& value);
  void add_path(std::string&& value);
  void add_path(const char* value);
  void add_path(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& path() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_path();

  // uint32 op = 2;
  void clear_op();
  static const int kOpFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::uint32 op() const;
  void set_op(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // bool isNot = 3;
  void clear_isnot();
  static const int kIsNotFieldNumber = 3;
  bool isnot() const;
  void set_isnot(bool value);

  // @@protoc_insertion_point(class_scope:pb.BOOL_GATE_OP)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> path_;
  ::PROTOBUF_NAMESPACE_ID::uint32 op_;
  bool isnot_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class boolGate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.boolGate) */ {
 public:
  boolGate();
  virtual ~boolGate();

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

  inline boolGate& operator=(const boolGate& from) {
    CopyFrom(from);
    return *this;
  }
  inline boolGate& operator=(boolGate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const boolGate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const boolGate* internal_default_instance() {
    return reinterpret_cast<const boolGate*>(
               &_boolGate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(boolGate* other);
  friend void swap(boolGate& a, boolGate& b) {
    a.Swap(&b);
  }

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

  inline boolGate* New() const final {
    return CreateMaybeMessage<boolGate>(nullptr);
  }

  boolGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<boolGate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const boolGate& from);
  void MergeFrom(const boolGate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(boolGate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.boolGate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
  int boolopspec_size() const;
  void clear_boolopspec();
  static const int kBoolOpSpecFieldNumber = 1;
  ::pb::BOOL_GATE_OP* mutable_boolopspec(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >*
      mutable_boolopspec();
  const ::pb::BOOL_GATE_OP& boolopspec(int index) const;
  ::pb::BOOL_GATE_OP* add_boolopspec();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >&
      boolopspec() const;

  // @@protoc_insertion_point(class_scope:pb.boolGate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP > boolopspec_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class clusterGate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.clusterGate) */ {
 public:
  clusterGate();
  virtual ~clusterGate();

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

  inline clusterGate& operator=(const clusterGate& from) {
    CopyFrom(from);
    return *this;
  }
  inline clusterGate& operator=(clusterGate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const clusterGate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const clusterGate* internal_default_instance() {
    return reinterpret_cast<const clusterGate*>(
               &_clusterGate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(clusterGate* other);
  friend void swap(clusterGate& a, clusterGate& b) {
    a.Swap(&b);
  }

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

  inline clusterGate* New() const final {
    return CreateMaybeMessage<clusterGate>(nullptr);
  }

  clusterGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<clusterGate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const clusterGate& from);
  void MergeFrom(const clusterGate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(clusterGate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.clusterGate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string cluster_method = 1;
  void clear_cluster_method();
  static const int kClusterMethodFieldNumber = 1;
  const std::string& cluster_method() const;
  void set_cluster_method(const std::string& value);
  void set_cluster_method(std::string&& value);
  void set_cluster_method(const char* value);
  void set_cluster_method(const char* value, size_t size);
  std::string* mutable_cluster_method();
  std::string* release_cluster_method();
  void set_allocated_cluster_method(std::string* cluster_method);

  // @@protoc_insertion_point(class_scope:pb.clusterGate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cluster_method_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class quadGate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.quadGate) */ {
 public:
  quadGate();
  virtual ~quadGate();

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

  inline quadGate& operator=(const quadGate& from) {
    CopyFrom(from);
    return *this;
  }
  inline quadGate& operator=(quadGate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const quadGate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const quadGate* internal_default_instance() {
    return reinterpret_cast<const quadGate*>(
               &_quadGate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(quadGate* other);
  friend void swap(quadGate& a, quadGate& b) {
    a.Swap(&b);
  }

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

  inline quadGate* New() const final {
    return CreateMaybeMessage<quadGate>(nullptr);
  }

  quadGate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<quadGate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const quadGate& from);
  void MergeFrom(const quadGate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(quadGate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.quadGate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string uid = 1;
  void clear_uid();
  static const int kUidFieldNumber = 1;
  const std::string& uid() const;
  void set_uid(const std::string& value);
  void set_uid(std::string&& value);
  void set_uid(const char* value);
  void set_uid(const char* value, size_t size);
  std::string* mutable_uid();
  std::string* release_uid();
  void set_allocated_uid(std::string* uid);

  // .pb.QUADRANT quadrant = 3;
  void clear_quadrant();
  static const int kQuadrantFieldNumber = 3;
  ::pb::QUADRANT quadrant() const;
  void set_quadrant(::pb::QUADRANT value);

  // @@protoc_insertion_point(class_scope:pb.quadGate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uid_;
  int quadrant_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class gate :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.gate) */ {
 public:
  gate();
  virtual ~gate();

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

  inline gate& operator=(const gate& from) {
    CopyFrom(from);
    return *this;
  }
  inline gate& operator=(gate&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const gate& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const gate* internal_default_instance() {
    return reinterpret_cast<const gate*>(
               &_gate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void Swap(gate* other);
  friend void swap(gate& a, gate& b) {
    a.Swap(&b);
  }

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

  inline gate* New() const final {
    return CreateMaybeMessage<gate>(nullptr);
  }

  gate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<gate>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const gate& from);
  void MergeFrom(const gate& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(gate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.gate";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // .pb.rangeGate rg = 5;
  bool has_rg() const;
  void clear_rg();
  static const int kRgFieldNumber = 5;
  const ::pb::rangeGate& rg() const;
  ::pb::rangeGate* release_rg();
  ::pb::rangeGate* mutable_rg();
  void set_allocated_rg(::pb::rangeGate* rg);

  // .pb.polygonGate pg = 6;
  bool has_pg() const;
  void clear_pg();
  static const int kPgFieldNumber = 6;
  const ::pb::polygonGate& pg() const;
  ::pb::polygonGate* release_pg();
  ::pb::polygonGate* mutable_pg();
  void set_allocated_pg(::pb::polygonGate* pg);

  // .pb.ellipseGate eg = 7;
  bool has_eg() const;
  void clear_eg();
  static const int kEgFieldNumber = 7;
  const ::pb::ellipseGate& eg() const;
  ::pb::ellipseGate* release_eg();
  ::pb::ellipseGate* mutable_eg();
  void set_allocated_eg(::pb::ellipseGate* eg);

  // .pb.boolGate bg = 8;
  bool has_bg() const;
  void clear_bg();
  static const int kBgFieldNumber = 8;
  const ::pb::boolGate& bg() const;
  ::pb::boolGate* release_bg();
  ::pb::boolGate* mutable_bg();
  void set_allocated_bg(::pb::boolGate* bg);

  // .pb.clusterGate cg = 9;
  bool has_cg() const;
  void clear_cg();
  static const int kCgFieldNumber = 9;
  const ::pb::clusterGate& cg() const;
  ::pb::clusterGate* release_cg();
  ::pb::clusterGate* mutable_cg();
  void set_allocated_cg(::pb::clusterGate* cg);

  // bool neg = 1;
  void clear_neg();
  static const int kNegFieldNumber = 1;
  bool neg() const;
  void set_neg(bool value);

  // bool isTransformed = 2;
  void clear_istransformed();
  static const int kIsTransformedFieldNumber = 2;
  bool istransformed() const;
  void set_istransformed(bool value);

  // bool isGained = 3;
  void clear_isgained();
  static const int kIsGainedFieldNumber = 3;
  bool isgained() const;
  void set_isgained(bool value);

  // .pb.GATE_TYPE type = 4;
  void clear_type();
  static const int kTypeFieldNumber = 4;
  ::pb::GATE_TYPE type() const;
  void set_type(::pb::GATE_TYPE value);

  // @@protoc_insertion_point(class_scope:pb.gate)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::pb::rangeGate* rg_;
  ::pb::polygonGate* pg_;
  ::pb::ellipseGate* eg_;
  ::pb::boolGate* bg_;
  ::pb::clusterGate* cg_;
  bool neg_;
  bool istransformed_;
  bool isgained_;
  int type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class POPSTATS :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.POPSTATS) */ {
 public:
  POPSTATS();
  virtual ~POPSTATS();

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

  inline POPSTATS& operator=(const POPSTATS& from) {
    CopyFrom(from);
    return *this;
  }
  inline POPSTATS& operator=(POPSTATS&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const POPSTATS& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const POPSTATS* internal_default_instance() {
    return reinterpret_cast<const POPSTATS*>(
               &_POPSTATS_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  void Swap(POPSTATS* other);
  friend void swap(POPSTATS& a, POPSTATS& b) {
    a.Swap(&b);
  }

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

  inline POPSTATS* New() const final {
    return CreateMaybeMessage<POPSTATS>(nullptr);
  }

  POPSTATS* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<POPSTATS>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const POPSTATS& from);
  void MergeFrom(const POPSTATS& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(POPSTATS* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.POPSTATS";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string statType = 1;
  void clear_stattype();
  static const int kStatTypeFieldNumber = 1;
  const std::string& stattype() const;
  void set_stattype(const std::string& value);
  void set_stattype(std::string&& value);
  void set_stattype(const char* value);
  void set_stattype(const char* value, size_t size);
  std::string* mutable_stattype();
  std::string* release_stattype();
  void set_allocated_stattype(std::string* stattype);

  // float statVal = 2;
  void clear_statval();
  static const int kStatValFieldNumber = 2;
  float statval() const;
  void set_statval(float value);

  // @@protoc_insertion_point(class_scope:pb.POPSTATS)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stattype_;
  float statval_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class calibrationTable :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.calibrationTable) */ {
 public:
  calibrationTable();
  virtual ~calibrationTable();

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

  inline calibrationTable& operator=(const calibrationTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline calibrationTable& operator=(calibrationTable&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const calibrationTable& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const calibrationTable* internal_default_instance() {
    return reinterpret_cast<const calibrationTable*>(
               &_calibrationTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  void Swap(calibrationTable* other);
  friend void swap(calibrationTable& a, calibrationTable& b) {
    a.Swap(&b);
  }

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

  inline calibrationTable* New() const final {
    return CreateMaybeMessage<calibrationTable>(nullptr);
  }

  calibrationTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<calibrationTable>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const calibrationTable& from);
  void MergeFrom(const calibrationTable& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(calibrationTable* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.calibrationTable";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated float x = 1 [packed = true];
  int x_size() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  float x(int index) const;
  void set_x(int index, float value);
  void add_x(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      x() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_x();

  // repeated float y = 2 [packed = true];
  int y_size() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  float y(int index) const;
  void set_y(int index, float value);
  void add_y(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      y() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_y();

  // repeated float b = 3 [packed = true];
  int b_size() const;
  void clear_b();
  static const int kBFieldNumber = 3;
  float b(int index) const;
  void set_b(int index, float value);
  void add_b(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      b() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_b();

  // repeated float c = 4 [packed = true];
  int c_size() const;
  void clear_c();
  static const int kCFieldNumber = 4;
  float c(int index) const;
  void set_c(int index, float value);
  void add_c(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      c() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_c();

  // repeated float d = 5 [packed = true];
  int d_size() const;
  void clear_d();
  static const int kDFieldNumber = 5;
  float d(int index) const;
  void set_d(int index, float value);
  void add_d(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      d() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_d();

  // string caltype = 7;
  void clear_caltype();
  static const int kCaltypeFieldNumber = 7;
  const std::string& caltype() const;
  void set_caltype(const std::string& value);
  void set_caltype(std::string&& value);
  void set_caltype(const char* value);
  void set_caltype(const char* value, size_t size);
  std::string* mutable_caltype();
  std::string* release_caltype();
  void set_allocated_caltype(std::string* caltype);

  // uint32 spline_method = 6;
  void clear_spline_method();
  static const int kSplineMethodFieldNumber = 6;
  ::PROTOBUF_NAMESPACE_ID::uint32 spline_method() const;
  void set_spline_method(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // bool flag = 8;
  void clear_flag();
  static const int kFlagFieldNumber = 8;
  bool flag() const;
  void set_flag(bool value);

  // @@protoc_insertion_point(class_scope:pb.calibrationTable)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > x_;
  mutable std::atomic<int> _x_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > y_;
  mutable std::atomic<int> _y_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > b_;
  mutable std::atomic<int> _b_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > c_;
  mutable std::atomic<int> _c_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > d_;
  mutable std::atomic<int> _d_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caltype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 spline_method_;
  bool flag_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class biexpTrans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.biexpTrans) */ {
 public:
  biexpTrans();
  virtual ~biexpTrans();

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

  inline biexpTrans& operator=(const biexpTrans& from) {
    CopyFrom(from);
    return *this;
  }
  inline biexpTrans& operator=(biexpTrans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const biexpTrans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const biexpTrans* internal_default_instance() {
    return reinterpret_cast<const biexpTrans*>(
               &_biexpTrans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  void Swap(biexpTrans* other);
  friend void swap(biexpTrans& a, biexpTrans& b) {
    a.Swap(&b);
  }

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

  inline biexpTrans* New() const final {
    return CreateMaybeMessage<biexpTrans>(nullptr);
  }

  biexpTrans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<biexpTrans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const biexpTrans& from);
  void MergeFrom(const biexpTrans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(biexpTrans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.biexpTrans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // uint32 channelRange = 1;
  void clear_channelrange();
  static const int kChannelRangeFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::uint32 channelrange() const;
  void set_channelrange(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // float pos = 2;
  void clear_pos();
  static const int kPosFieldNumber = 2;
  float pos() const;
  void set_pos(float value);

  // float neg = 3;
  void clear_neg();
  static const int kNegFieldNumber = 3;
  float neg() const;
  void set_neg(float value);

  // float widthBasis = 4;
  void clear_widthbasis();
  static const int kWidthBasisFieldNumber = 4;
  float widthbasis() const;
  void set_widthbasis(float value);

  // float maxValue = 5;
  void clear_maxvalue();
  static const int kMaxValueFieldNumber = 5;
  float maxvalue() const;
  void set_maxvalue(float value);

  // @@protoc_insertion_point(class_scope:pb.biexpTrans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::uint32 channelrange_;
  float pos_;
  float neg_;
  float widthbasis_;
  float maxvalue_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class fasinhTrans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.fasinhTrans) */ {
 public:
  fasinhTrans();
  virtual ~fasinhTrans();

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

  inline fasinhTrans& operator=(const fasinhTrans& from) {
    CopyFrom(from);
    return *this;
  }
  inline fasinhTrans& operator=(fasinhTrans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const fasinhTrans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const fasinhTrans* internal_default_instance() {
    return reinterpret_cast<const fasinhTrans*>(
               &_fasinhTrans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  void Swap(fasinhTrans* other);
  friend void swap(fasinhTrans& a, fasinhTrans& b) {
    a.Swap(&b);
  }

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

  inline fasinhTrans* New() const final {
    return CreateMaybeMessage<fasinhTrans>(nullptr);
  }

  fasinhTrans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<fasinhTrans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const fasinhTrans& from);
  void MergeFrom(const fasinhTrans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(fasinhTrans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.fasinhTrans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float length = 1;
  void clear_length();
  static const int kLengthFieldNumber = 1;
  float length() const;
  void set_length(float value);

  // float maxRange = 2;
  void clear_maxrange();
  static const int kMaxRangeFieldNumber = 2;
  float maxrange() const;
  void set_maxrange(float value);

  // float T = 3;
  void clear_t();
  static const int kTFieldNumber = 3;
  float t() const;
  void set_t(float value);

  // float A = 4;
  void clear_a();
  static const int kAFieldNumber = 4;
  float a() const;
  void set_a(float value);

  // float M = 5;
  void clear_m();
  static const int kMFieldNumber = 5;
  float m() const;
  void set_m(float value);

  // @@protoc_insertion_point(class_scope:pb.fasinhTrans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float length_;
  float maxrange_;
  float t_;
  float a_;
  float m_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class scaleTrans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.scaleTrans) */ {
 public:
  scaleTrans();
  virtual ~scaleTrans();

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

  inline scaleTrans& operator=(const scaleTrans& from) {
    CopyFrom(from);
    return *this;
  }
  inline scaleTrans& operator=(scaleTrans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const scaleTrans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const scaleTrans* internal_default_instance() {
    return reinterpret_cast<const scaleTrans*>(
               &_scaleTrans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  void Swap(scaleTrans* other);
  friend void swap(scaleTrans& a, scaleTrans& b) {
    a.Swap(&b);
  }

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

  inline scaleTrans* New() const final {
    return CreateMaybeMessage<scaleTrans>(nullptr);
  }

  scaleTrans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<scaleTrans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const scaleTrans& from);
  void MergeFrom(const scaleTrans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(scaleTrans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.scaleTrans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float scale_factor = 1;
  void clear_scale_factor();
  static const int kScaleFactorFieldNumber = 1;
  float scale_factor() const;
  void set_scale_factor(float value);

  // float t_scale = 2;
  void clear_t_scale();
  static const int kTScaleFieldNumber = 2;
  float t_scale() const;
  void set_t_scale(float value);

  // float r_scale = 3;
  void clear_r_scale();
  static const int kRScaleFieldNumber = 3;
  float r_scale() const;
  void set_r_scale(float value);

  // @@protoc_insertion_point(class_scope:pb.scaleTrans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float scale_factor_;
  float t_scale_;
  float r_scale_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class flinTrans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.flinTrans) */ {
 public:
  flinTrans();
  virtual ~flinTrans();

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

  inline flinTrans& operator=(const flinTrans& from) {
    CopyFrom(from);
    return *this;
  }
  inline flinTrans& operator=(flinTrans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const flinTrans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const flinTrans* internal_default_instance() {
    return reinterpret_cast<const flinTrans*>(
               &_flinTrans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  void Swap(flinTrans* other);
  friend void swap(flinTrans& a, flinTrans& b) {
    a.Swap(&b);
  }

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

  inline flinTrans* New() const final {
    return CreateMaybeMessage<flinTrans>(nullptr);
  }

  flinTrans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<flinTrans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const flinTrans& from);
  void MergeFrom(const flinTrans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(flinTrans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.flinTrans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float min = 1;
  void clear_min();
  static const int kMinFieldNumber = 1;
  float min() const;
  void set_min(float value);

  // float max = 2;
  void clear_max();
  static const int kMaxFieldNumber = 2;
  float max() const;
  void set_max(float value);

  // @@protoc_insertion_point(class_scope:pb.flinTrans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float min_;
  float max_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class logTrans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.logTrans) */ {
 public:
  logTrans();
  virtual ~logTrans();

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

  inline logTrans& operator=(const logTrans& from) {
    CopyFrom(from);
    return *this;
  }
  inline logTrans& operator=(logTrans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const logTrans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const logTrans* internal_default_instance() {
    return reinterpret_cast<const logTrans*>(
               &_logTrans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  void Swap(logTrans* other);
  friend void swap(logTrans& a, logTrans& b) {
    a.Swap(&b);
  }

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

  inline logTrans* New() const final {
    return CreateMaybeMessage<logTrans>(nullptr);
  }

  logTrans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<logTrans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const logTrans& from);
  void MergeFrom(const logTrans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(logTrans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.logTrans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float offset = 1;
  void clear_offset();
  static const int kOffsetFieldNumber = 1;
  float offset() const;
  void set_offset(float value);

  // float decade = 2;
  void clear_decade();
  static const int kDecadeFieldNumber = 2;
  float decade() const;
  void set_decade(float value);

  // float T = 3;
  void clear_t();
  static const int kTFieldNumber = 3;
  float t() const;
  void set_t(float value);

  // float scale = 4;
  void clear_scale();
  static const int kScaleFieldNumber = 4;
  float scale() const;
  void set_scale(float value);

  // @@protoc_insertion_point(class_scope:pb.logTrans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float offset_;
  float decade_;
  float t_;
  float scale_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class logGML2Trans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.logGML2Trans) */ {
 public:
  logGML2Trans();
  virtual ~logGML2Trans();

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

  inline logGML2Trans& operator=(const logGML2Trans& from) {
    CopyFrom(from);
    return *this;
  }
  inline logGML2Trans& operator=(logGML2Trans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const logGML2Trans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const logGML2Trans* internal_default_instance() {
    return reinterpret_cast<const logGML2Trans*>(
               &_logGML2Trans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  void Swap(logGML2Trans* other);
  friend void swap(logGML2Trans& a, logGML2Trans& b) {
    a.Swap(&b);
  }

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

  inline logGML2Trans* New() const final {
    return CreateMaybeMessage<logGML2Trans>(nullptr);
  }

  logGML2Trans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<logGML2Trans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const logGML2Trans& from);
  void MergeFrom(const logGML2Trans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(logGML2Trans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.logGML2Trans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float T = 1;
  void clear_t();
  static const int kTFieldNumber = 1;
  float t() const;
  void set_t(float value);

  // float M = 2;
  void clear_m();
  static const int kMFieldNumber = 2;
  float m() const;
  void set_m(float value);

  // @@protoc_insertion_point(class_scope:pb.logGML2Trans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float t_;
  float m_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class logicleTrans :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.logicleTrans) */ {
 public:
  logicleTrans();
  virtual ~logicleTrans();

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

  inline logicleTrans& operator=(const logicleTrans& from) {
    CopyFrom(from);
    return *this;
  }
  inline logicleTrans& operator=(logicleTrans&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const logicleTrans& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const logicleTrans* internal_default_instance() {
    return reinterpret_cast<const logicleTrans*>(
               &_logicleTrans_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  void Swap(logicleTrans* other);
  friend void swap(logicleTrans& a, logicleTrans& b) {
    a.Swap(&b);
  }

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

  inline logicleTrans* New() const final {
    return CreateMaybeMessage<logicleTrans>(nullptr);
  }

  logicleTrans* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<logicleTrans>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const logicleTrans& from);
  void MergeFrom(const logicleTrans& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(logicleTrans* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.logicleTrans";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // float T = 1;
  void clear_t();
  static const int kTFieldNumber = 1;
  float t() const;
  void set_t(float value);

  // float W = 2;
  void clear_w();
  static const int kWFieldNumber = 2;
  float w() const;
  void set_w(float value);

  // float M = 3;
  void clear_m();
  static const int kMFieldNumber = 3;
  float m() const;
  void set_m(float value);

  // float A = 4;
  void clear_a();
  static const int kAFieldNumber = 4;
  float a() const;
  void set_a(float value);

  // float bins = 5;
  void clear_bins();
  static const int kBinsFieldNumber = 5;
  float bins() const;
  void set_bins(float value);

  // bool isGml2 = 6;
  void clear_isgml2();
  static const int kIsGml2FieldNumber = 6;
  bool isgml2() const;
  void set_isgml2(bool value);

  // bool isInverse = 7;
  void clear_isinverse();
  static const int kIsInverseFieldNumber = 7;
  bool isinverse() const;
  void set_isinverse(bool value);

  // @@protoc_insertion_point(class_scope:pb.logicleTrans)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  float t_;
  float w_;
  float m_;
  float a_;
  float bins_;
  bool isgml2_;
  bool isinverse_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class transformation :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.transformation) */ {
 public:
  transformation();
  virtual ~transformation();

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

  inline transformation& operator=(const transformation& from) {
    CopyFrom(from);
    return *this;
  }
  inline transformation& operator=(transformation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const transformation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const transformation* internal_default_instance() {
    return reinterpret_cast<const transformation*>(
               &_transformation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  void Swap(transformation* other);
  friend void swap(transformation& a, transformation& b) {
    a.Swap(&b);
  }

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

  inline transformation* New() const final {
    return CreateMaybeMessage<transformation>(nullptr);
  }

  transformation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<transformation>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const transformation& from);
  void MergeFrom(const transformation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(transformation* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.transformation";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string name = 4;
  void clear_name();
  static const int kNameFieldNumber = 4;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string channel = 5;
  void clear_channel();
  static const int kChannelFieldNumber = 5;
  const std::string& channel() const;
  void set_channel(const std::string& value);
  void set_channel(std::string&& value);
  void set_channel(const char* value);
  void set_channel(const char* value, size_t size);
  std::string* mutable_channel();
  std::string* release_channel();
  void set_allocated_channel(std::string* channel);

  // .pb.calibrationTable calTbl = 1;
  bool has_caltbl() const;
  void clear_caltbl();
  static const int kCalTblFieldNumber = 1;
  const ::pb::calibrationTable& caltbl() const;
  ::pb::calibrationTable* release_caltbl();
  ::pb::calibrationTable* mutable_caltbl();
  void set_allocated_caltbl(::pb::calibrationTable* caltbl);

  // .pb.biexpTrans bt = 7;
  bool has_bt() const;
  void clear_bt();
  static const int kBtFieldNumber = 7;
  const ::pb::biexpTrans& bt() const;
  ::pb::biexpTrans* release_bt();
  ::pb::biexpTrans* mutable_bt();
  void set_allocated_bt(::pb::biexpTrans* bt);

  // .pb.logTrans lt = 8;
  bool has_lt() const;
  void clear_lt();
  static const int kLtFieldNumber = 8;
  const ::pb::logTrans& lt() const;
  ::pb::logTrans* release_lt();
  ::pb::logTrans* mutable_lt();
  void set_allocated_lt(::pb::logTrans* lt);

  // .pb.flinTrans flt = 9;
  bool has_flt() const;
  void clear_flt();
  static const int kFltFieldNumber = 9;
  const ::pb::flinTrans& flt() const;
  ::pb::flinTrans* release_flt();
  ::pb::flinTrans* mutable_flt();
  void set_allocated_flt(::pb::flinTrans* flt);

  // .pb.scaleTrans st = 10;
  bool has_st() const;
  void clear_st();
  static const int kStFieldNumber = 10;
  const ::pb::scaleTrans& st() const;
  ::pb::scaleTrans* release_st();
  ::pb::scaleTrans* mutable_st();
  void set_allocated_st(::pb::scaleTrans* st);

  // .pb.fasinhTrans ft = 11;
  bool has_ft() const;
  void clear_ft();
  static const int kFtFieldNumber = 11;
  const ::pb::fasinhTrans& ft() const;
  ::pb::fasinhTrans* release_ft();
  ::pb::fasinhTrans* mutable_ft();
  void set_allocated_ft(::pb::fasinhTrans* ft);

  // .pb.logicleTrans lgt = 13;
  bool has_lgt() const;
  void clear_lgt();
  static const int kLgtFieldNumber = 13;
  const ::pb::logicleTrans& lgt() const;
  ::pb::logicleTrans* release_lgt();
  ::pb::logicleTrans* mutable_lgt();
  void set_allocated_lgt(::pb::logicleTrans* lgt);

  // .pb.logGML2Trans lgml2t = 14;
  bool has_lgml2t() const;
  void clear_lgml2t();
  static const int kLgml2TFieldNumber = 14;
  const ::pb::logGML2Trans& lgml2t() const;
  ::pb::logGML2Trans* release_lgml2t();
  ::pb::logGML2Trans* mutable_lgml2t();
  void set_allocated_lgml2t(::pb::logGML2Trans* lgml2t);

  // .pb.TRANS_TYPE trans_type = 3;
  void clear_trans_type();
  static const int kTransTypeFieldNumber = 3;
  ::pb::TRANS_TYPE trans_type() const;
  void set_trans_type(::pb::TRANS_TYPE value);

  // bool isGateOnly = 2;
  void clear_isgateonly();
  static const int kIsGateOnlyFieldNumber = 2;
  bool isgateonly() const;
  void set_isgateonly(bool value);

  // bool isComputed = 6;
  void clear_iscomputed();
  static const int kIsComputedFieldNumber = 6;
  bool iscomputed() const;
  void set_iscomputed(bool value);

  // uint32 type = 12;
  void clear_type();
  static const int kTypeFieldNumber = 12;
  ::PROTOBUF_NAMESPACE_ID::uint32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:pb.transformation)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr channel_;
  ::pb::calibrationTable* caltbl_;
  ::pb::biexpTrans* bt_;
  ::pb::logTrans* lt_;
  ::pb::flinTrans* flt_;
  ::pb::scaleTrans* st_;
  ::pb::fasinhTrans* ft_;
  ::pb::logicleTrans* lgt_;
  ::pb::logGML2Trans* lgml2t_;
  int trans_type_;
  bool isgateonly_;
  bool iscomputed_;
  ::PROTOBUF_NAMESPACE_ID::uint32 type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class trans_pair :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.trans_pair) */ {
 public:
  trans_pair();
  virtual ~trans_pair();

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

  inline trans_pair& operator=(const trans_pair& from) {
    CopyFrom(from);
    return *this;
  }
  inline trans_pair& operator=(trans_pair&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const trans_pair& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const trans_pair* internal_default_instance() {
    return reinterpret_cast<const trans_pair*>(
               &_trans_pair_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  void Swap(trans_pair* other);
  friend void swap(trans_pair& a, trans_pair& b) {
    a.Swap(&b);
  }

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

  inline trans_pair* New() const final {
    return CreateMaybeMessage<trans_pair>(nullptr);
  }

  trans_pair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<trans_pair>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const trans_pair& from);
  void MergeFrom(const trans_pair& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(trans_pair* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.trans_pair";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // .pb.transformation trans = 3;
  bool has_trans() const;
  void clear_trans();
  static const int kTransFieldNumber = 3;
  const ::pb::transformation& trans() const;
  ::pb::transformation* release_trans();
  ::pb::transformation* mutable_trans();
  void set_allocated_trans(::pb::transformation* trans);

  // uint64 trans_address = 2;
  void clear_trans_address();
  static const int kTransAddressFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::uint64 trans_address() const;
  void set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:pb.trans_pair)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::pb::transformation* trans_;
  ::PROTOBUF_NAMESPACE_ID::uint64 trans_address_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class trans_local :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.trans_local) */ {
 public:
  trans_local();
  virtual ~trans_local();

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

  inline trans_local& operator=(const trans_local& from) {
    CopyFrom(from);
    return *this;
  }
  inline trans_local& operator=(trans_local&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const trans_local& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const trans_local* internal_default_instance() {
    return reinterpret_cast<const trans_local*>(
               &_trans_local_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  void Swap(trans_local* other);
  friend void swap(trans_local& a, trans_local& b) {
    a.Swap(&b);
  }

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

  inline trans_local* New() const final {
    return CreateMaybeMessage<trans_local>(nullptr);
  }

  trans_local* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<trans_local>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const trans_local& from);
  void MergeFrom(const trans_local& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(trans_local* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.trans_local";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated .pb.trans_pair tp = 1;
  int tp_size() const;
  void clear_tp();
  static const int kTpFieldNumber = 1;
  ::pb::trans_pair* mutable_tp(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >*
      mutable_tp();
  const ::pb::trans_pair& tp(int index) const;
  ::pb::trans_pair* add_tp();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >&
      tp() const;

  // repeated uint32 sampleIDs = 3 [packed = true];
  int sampleids_size() const;
  void clear_sampleids();
  static const int kSampleIDsFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::uint32 sampleids(int index) const;
  void set_sampleids(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value);
  void add_sampleids(::PROTOBUF_NAMESPACE_ID::uint32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
      sampleids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
      mutable_sampleids();

  // string groupName = 2;
  void clear_groupname();
  static const int kGroupNameFieldNumber = 2;
  const std::string& groupname() const;
  void set_groupname(const std::string& value);
  void set_groupname(std::string&& value);
  void set_groupname(const char* value);
  void set_groupname(const char* value, size_t size);
  std::string* mutable_groupname();
  std::string* release_groupname();
  void set_allocated_groupname(std::string* groupname);

  // @@protoc_insertion_point(class_scope:pb.trans_local)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair > tp_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > sampleids_;
  mutable std::atomic<int> _sampleids_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class POPINDICES :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.POPINDICES) */ {
 public:
  POPINDICES();
  virtual ~POPINDICES();

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

  inline POPINDICES& operator=(const POPINDICES& from) {
    CopyFrom(from);
    return *this;
  }
  inline POPINDICES& operator=(POPINDICES&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const POPINDICES& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const POPINDICES* internal_default_instance() {
    return reinterpret_cast<const POPINDICES*>(
               &_POPINDICES_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  void Swap(POPINDICES* other);
  friend void swap(POPINDICES& a, POPINDICES& b) {
    a.Swap(&b);
  }

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

  inline POPINDICES* New() const final {
    return CreateMaybeMessage<POPINDICES>(nullptr);
  }

  POPINDICES* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<POPINDICES>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const POPINDICES& from);
  void MergeFrom(const POPINDICES& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(POPINDICES* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.POPINDICES";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated uint32 iInd = 3 [packed = true];
  int iind_size() const;
  void clear_iind();
  static const int kIIndFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::uint32 iind(int index) const;
  void set_iind(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value);
  void add_iind(::PROTOBUF_NAMESPACE_ID::uint32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
      iind() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
      mutable_iind();

  // bytes bInd = 4;
  void clear_bind();
  static const int kBIndFieldNumber = 4;
  const std::string& bind() const;
  void set_bind(const std::string& value);
  void set_bind(std::string&& value);
  void set_bind(const char* value);
  void set_bind(const void* value, size_t size);
  std::string* mutable_bind();
  std::string* release_bind();
  void set_allocated_bind(std::string* bind);

  // uint32 nEvents = 1;
  void clear_nevents();
  static const int kNEventsFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::uint32 nevents() const;
  void set_nevents(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // .pb.ind_type indtype = 2;
  void clear_indtype();
  static const int kIndtypeFieldNumber = 2;
  ::pb::ind_type indtype() const;
  void set_indtype(::pb::ind_type value);

  // @@protoc_insertion_point(class_scope:pb.POPINDICES)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > iind_;
  mutable std::atomic<int> _iind_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bind_;
  ::PROTOBUF_NAMESPACE_ID::uint32 nevents_;
  int indtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class nodeProperties :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.nodeProperties) */ {
 public:
  nodeProperties();
  virtual ~nodeProperties();

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

  inline nodeProperties& operator=(const nodeProperties& from) {
    CopyFrom(from);
    return *this;
  }
  inline nodeProperties& operator=(nodeProperties&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const nodeProperties& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const nodeProperties* internal_default_instance() {
    return reinterpret_cast<const nodeProperties*>(
               &_nodeProperties_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  void Swap(nodeProperties* other);
  friend void swap(nodeProperties& a, nodeProperties& b) {
    a.Swap(&b);
  }

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

  inline nodeProperties* New() const final {
    return CreateMaybeMessage<nodeProperties>(nullptr);
  }

  nodeProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<nodeProperties>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const nodeProperties& from);
  void MergeFrom(const nodeProperties& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(nodeProperties* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.nodeProperties";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated .pb.POPSTATS fjStats = 2;
  int fjstats_size() const;
  void clear_fjstats();
  static const int kFjStatsFieldNumber = 2;
  ::pb::POPSTATS* mutable_fjstats(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >*
      mutable_fjstats();
  const ::pb::POPSTATS& fjstats(int index) const;
  ::pb::POPSTATS* add_fjstats();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >&
      fjstats() const;

  // repeated .pb.POPSTATS fcStats = 3;
  int fcstats_size() const;
  void clear_fcstats();
  static const int kFcStatsFieldNumber = 3;
  ::pb::POPSTATS* mutable_fcstats(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >*
      mutable_fcstats();
  const ::pb::POPSTATS& fcstats(int index) const;
  ::pb::POPSTATS* add_fcstats();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >&
      fcstats() const;

  // string thisName = 1;
  void clear_thisname();
  static const int kThisNameFieldNumber = 1;
  const std::string& thisname() const;
  void set_thisname(const std::string& value);
  void set_thisname(std::string&& value);
  void set_thisname(const char* value);
  void set_thisname(const char* value, size_t size);
  std::string* mutable_thisname();
  std::string* release_thisname();
  void set_allocated_thisname(std::string* thisname);

  // .pb.POPINDICES indices = 5;
  bool has_indices() const;
  void clear_indices();
  static const int kIndicesFieldNumber = 5;
  const ::pb::POPINDICES& indices() const;
  ::pb::POPINDICES* release_indices();
  ::pb::POPINDICES* mutable_indices();
  void set_allocated_indices(::pb::POPINDICES* indices);

  // .pb.gate thisGate = 6;
  bool has_thisgate() const;
  void clear_thisgate();
  static const int kThisGateFieldNumber = 6;
  const ::pb::gate& thisgate() const;
  ::pb::gate* release_thisgate();
  ::pb::gate* mutable_thisgate();
  void set_allocated_thisgate(::pb::gate* thisgate);

  // bool hidden = 4;
  void clear_hidden();
  static const int kHiddenFieldNumber = 4;
  bool hidden() const;
  void set_hidden(bool value);

  // @@protoc_insertion_point(class_scope:pb.nodeProperties)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS > fjstats_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS > fcstats_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thisname_;
  ::pb::POPINDICES* indices_;
  ::pb::gate* thisgate_;
  bool hidden_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class treeNodes :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.treeNodes) */ {
 public:
  treeNodes();
  virtual ~treeNodes();

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

  inline treeNodes& operator=(const treeNodes& from) {
    CopyFrom(from);
    return *this;
  }
  inline treeNodes& operator=(treeNodes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const treeNodes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const treeNodes* internal_default_instance() {
    return reinterpret_cast<const treeNodes*>(
               &_treeNodes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  void Swap(treeNodes* other);
  friend void swap(treeNodes& a, treeNodes& b) {
    a.Swap(&b);
  }

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

  inline treeNodes* New() const final {
    return CreateMaybeMessage<treeNodes>(nullptr);
  }

  treeNodes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<treeNodes>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const treeNodes& from);
  void MergeFrom(const treeNodes& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(treeNodes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.treeNodes";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // .pb.nodeProperties node = 1;
  bool has_node() const;
  void clear_node();
  static const int kNodeFieldNumber = 1;
  const ::pb::nodeProperties& node() const;
  ::pb::nodeProperties* release_node();
  ::pb::nodeProperties* mutable_node();
  void set_allocated_node(::pb::nodeProperties* node);

  // uint32 parent = 2;
  void clear_parent();
  static const int kParentFieldNumber = 2;
  ::PROTOBUF_NAMESPACE_ID::uint32 parent() const;
  void set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:pb.treeNodes)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::pb::nodeProperties* node_;
  ::PROTOBUF_NAMESPACE_ID::uint32 parent_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class populationTree :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.populationTree) */ {
 public:
  populationTree();
  virtual ~populationTree();

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

  inline populationTree& operator=(const populationTree& from) {
    CopyFrom(from);
    return *this;
  }
  inline populationTree& operator=(populationTree&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const populationTree& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const populationTree* internal_default_instance() {
    return reinterpret_cast<const populationTree*>(
               &_populationTree_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  void Swap(populationTree* other);
  friend void swap(populationTree& a, populationTree& b) {
    a.Swap(&b);
  }

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

  inline populationTree* New() const final {
    return CreateMaybeMessage<populationTree>(nullptr);
  }

  populationTree* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<populationTree>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const populationTree& from);
  void MergeFrom(const populationTree& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(populationTree* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.populationTree";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated .pb.treeNodes node = 1;
  int node_size() const;
  void clear_node();
  static const int kNodeFieldNumber = 1;
  ::pb::treeNodes* mutable_node(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >*
      mutable_node();
  const ::pb::treeNodes& node(int index) const;
  ::pb::treeNodes* add_node();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >&
      node() const;

  // @@protoc_insertion_point(class_scope:pb.populationTree)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes > node_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class COMP :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.COMP) */ {
 public:
  COMP();
  virtual ~COMP();

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

  inline COMP& operator=(const COMP& from) {
    CopyFrom(from);
    return *this;
  }
  inline COMP& operator=(COMP&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const COMP& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const COMP* internal_default_instance() {
    return reinterpret_cast<const COMP*>(
               &_COMP_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  void Swap(COMP* other);
  friend void swap(COMP& a, COMP& b) {
    a.Swap(&b);
  }

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

  inline COMP* New() const final {
    return CreateMaybeMessage<COMP>(nullptr);
  }

  COMP* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<COMP>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const COMP& from);
  void MergeFrom(const COMP& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(COMP* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.COMP";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated string marker = 6;
  int marker_size() const;
  void clear_marker();
  static const int kMarkerFieldNumber = 6;
  const std::string& marker(int index) const;
  std::string* mutable_marker(int index);
  void set_marker(int index, const std::string& value);
  void set_marker(int index, std::string&& value);
  void set_marker(int index, const char* value);
  void set_marker(int index, const char* value, size_t size);
  std::string* add_marker();
  void add_marker(const std::string& value);
  void add_marker(std::string&& value);
  void add_marker(const char* value);
  void add_marker(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& marker() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_marker();

  // repeated float spillOver = 7;
  int spillover_size() const;
  void clear_spillover();
  static const int kSpillOverFieldNumber = 7;
  float spillover(int index) const;
  void set_spillover(int index, float value);
  void add_spillover(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      spillover() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_spillover();

  // repeated string detector = 8;
  int detector_size() const;
  void clear_detector();
  static const int kDetectorFieldNumber = 8;
  const std::string& detector(int index) const;
  std::string* mutable_detector(int index);
  void set_detector(int index, const std::string& value);
  void set_detector(int index, std::string&& value);
  void set_detector(int index, const char* value);
  void set_detector(int index, const char* value, size_t size);
  std::string* add_detector();
  void add_detector(const std::string& value);
  void add_detector(std::string&& value);
  void add_detector(const char* value);
  void add_detector(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& detector() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_detector();

  // string cid = 1;
  void clear_cid();
  static const int kCidFieldNumber = 1;
  const std::string& cid() const;
  void set_cid(const std::string& value);
  void set_cid(std::string&& value);
  void set_cid(const char* value);
  void set_cid(const char* value, size_t size);
  std::string* mutable_cid();
  std::string* release_cid();
  void set_allocated_cid(std::string* cid);

  // string prefix = 2;
  void clear_prefix();
  static const int kPrefixFieldNumber = 2;
  const std::string& prefix() const;
  void set_prefix(const std::string& value);
  void set_prefix(std::string&& value);
  void set_prefix(const char* value);
  void set_prefix(const char* value, size_t size);
  std::string* mutable_prefix();
  std::string* release_prefix();
  void set_allocated_prefix(std::string* prefix);

  // string suffix = 3;
  void clear_suffix();
  static const int kSuffixFieldNumber = 3;
  const std::string& suffix() const;
  void set_suffix(const std::string& value);
  void set_suffix(std::string&& value);
  void set_suffix(const char* value);
  void set_suffix(const char* value, size_t size);
  std::string* mutable_suffix();
  std::string* release_suffix();
  void set_allocated_suffix(std::string* suffix);

  // string name = 4;
  void clear_name();
  static const int kNameFieldNumber = 4;
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // string comment = 5;
  void clear_comment();
  static const int kCommentFieldNumber = 5;
  const std::string& comment() const;
  void set_comment(const std::string& value);
  void set_comment(std::string&& value);
  void set_comment(const char* value);
  void set_comment(const char* value, size_t size);
  std::string* mutable_comment();
  std::string* release_comment();
  void set_allocated_comment(std::string* comment);

  // @@protoc_insertion_point(class_scope:pb.COMP)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> marker_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > spillover_;
  mutable std::atomic<int> _spillover_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> detector_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr suffix_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class PARAM :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.PARAM) */ {
 public:
  PARAM();
  virtual ~PARAM();

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

  inline PARAM& operator=(const PARAM& from) {
    CopyFrom(from);
    return *this;
  }
  inline PARAM& operator=(PARAM&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PARAM& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PARAM* internal_default_instance() {
    return reinterpret_cast<const PARAM*>(
               &_PARAM_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  void Swap(PARAM* other);
  friend void swap(PARAM& a, PARAM& b) {
    a.Swap(&b);
  }

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

  inline PARAM* New() const final {
    return CreateMaybeMessage<PARAM>(nullptr);
  }

  PARAM* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PARAM>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PARAM& from);
  void MergeFrom(const PARAM& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PARAM* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.PARAM";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // string param = 1;
  void clear_param();
  static const int kParamFieldNumber = 1;
  const std::string& param() const;
  void set_param(const std::string& value);
  void set_param(std::string&& value);
  void set_param(const char* value);
  void set_param(const char* value, size_t size);
  std::string* mutable_param();
  std::string* release_param();
  void set_allocated_param(std::string* param);

  // bool log = 2;
  void clear_log();
  static const int kLogFieldNumber = 2;
  bool log() const;
  void set_log(bool value);

  // uint32 range = 3;
  void clear_range();
  static const int kRangeFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::uint32 range() const;
  void set_range(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 highValue = 4;
  void clear_highvalue();
  static const int kHighValueFieldNumber = 4;
  ::PROTOBUF_NAMESPACE_ID::uint32 highvalue() const;
  void set_highvalue(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // uint32 calibrationIndex = 5;
  void clear_calibrationindex();
  static const int kCalibrationIndexFieldNumber = 5;
  ::PROTOBUF_NAMESPACE_ID::uint32 calibrationindex() const;
  void set_calibrationindex(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:pb.PARAM)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_;
  bool log_;
  ::PROTOBUF_NAMESPACE_ID::uint32 range_;
  ::PROTOBUF_NAMESPACE_ID::uint32 highvalue_;
  ::PROTOBUF_NAMESPACE_ID::uint32 calibrationindex_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class GatingHierarchy :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.GatingHierarchy) */ {
 public:
  GatingHierarchy();
  virtual ~GatingHierarchy();

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

  inline GatingHierarchy& operator=(const GatingHierarchy& from) {
    CopyFrom(from);
    return *this;
  }
  inline GatingHierarchy& operator=(GatingHierarchy&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GatingHierarchy& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GatingHierarchy* internal_default_instance() {
    return reinterpret_cast<const GatingHierarchy*>(
               &_GatingHierarchy_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  void Swap(GatingHierarchy* other);
  friend void swap(GatingHierarchy& a, GatingHierarchy& b) {
    a.Swap(&b);
  }

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

  inline GatingHierarchy* New() const final {
    return CreateMaybeMessage<GatingHierarchy>(nullptr);
  }

  GatingHierarchy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GatingHierarchy>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GatingHierarchy& from);
  void MergeFrom(const GatingHierarchy& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GatingHierarchy* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.GatingHierarchy";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated .pb.PARAM transFlag = 4;
  int transflag_size() const;
  void clear_transflag();
  static const int kTransFlagFieldNumber = 4;
  ::pb::PARAM* mutable_transflag(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >*
      mutable_transflag();
  const ::pb::PARAM& transflag(int index) const;
  ::pb::PARAM* add_transflag();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >&
      transflag() const;

  // .pb.COMP comp = 1;
  bool has_comp() const;
  void clear_comp();
  static const int kCompFieldNumber = 1;
  const ::pb::COMP& comp() const;
  ::pb::COMP* release_comp();
  ::pb::COMP* mutable_comp();
  void set_allocated_comp(::pb::COMP* comp);

  // .pb.populationTree tree = 2;
  bool has_tree() const;
  void clear_tree();
  static const int kTreeFieldNumber = 2;
  const ::pb::populationTree& tree() const;
  ::pb::populationTree* release_tree();
  ::pb::populationTree* mutable_tree();
  void set_allocated_tree(::pb::populationTree* tree);

  // .pb.trans_local trans = 5;
  bool has_trans() const;
  void clear_trans();
  static const int kTransFieldNumber = 5;
  const ::pb::trans_local& trans() const;
  ::pb::trans_local* release_trans();
  ::pb::trans_local* mutable_trans();
  void set_allocated_trans(::pb::trans_local* trans);

  // .pb.CytoFrame frame = 6;
  bool has_frame() const;
  void clear_frame();
  static const int kFrameFieldNumber = 6;
  const ::pb::CytoFrame& frame() const;
  ::pb::CytoFrame* release_frame();
  ::pb::CytoFrame* mutable_frame();
  void set_allocated_frame(::pb::CytoFrame* frame);

  // bool isLoaded = 3;
  void clear_isloaded();
  static const int kIsLoadedFieldNumber = 3;
  bool isloaded() const;
  void set_isloaded(bool value);

  // @@protoc_insertion_point(class_scope:pb.GatingHierarchy)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM > transflag_;
  ::pb::COMP* comp_;
  ::pb::populationTree* tree_;
  ::pb::trans_local* trans_;
  ::pb::CytoFrame* frame_;
  bool isloaded_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class CytoFrame :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.CytoFrame) */ {
 public:
  CytoFrame();
  virtual ~CytoFrame();

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

  inline CytoFrame& operator=(const CytoFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline CytoFrame& operator=(CytoFrame&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CytoFrame& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CytoFrame* internal_default_instance() {
    return reinterpret_cast<const CytoFrame*>(
               &_CytoFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  void Swap(CytoFrame* other);
  friend void swap(CytoFrame& a, CytoFrame& b) {
    a.Swap(&b);
  }

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

  inline CytoFrame* New() const final {
    return CreateMaybeMessage<CytoFrame>(nullptr);
  }

  CytoFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CytoFrame>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CytoFrame& from);
  void MergeFrom(const CytoFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CytoFrame* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.CytoFrame";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // bool is_h5 = 1;
  void clear_is_h5();
  static const int kIsH5FieldNumber = 1;
  bool is_h5() const;
  void set_is_h5(bool value);

  // @@protoc_insertion_point(class_scope:pb.CytoFrame)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  bool is_h5_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class TRANS_TBL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.TRANS_TBL) */ {
 public:
  TRANS_TBL();
  virtual ~TRANS_TBL();

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

  inline TRANS_TBL& operator=(const TRANS_TBL& from) {
    CopyFrom(from);
    return *this;
  }
  inline TRANS_TBL& operator=(TRANS_TBL&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TRANS_TBL& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TRANS_TBL* internal_default_instance() {
    return reinterpret_cast<const TRANS_TBL*>(
               &_TRANS_TBL_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  void Swap(TRANS_TBL* other);
  friend void swap(TRANS_TBL& a, TRANS_TBL& b) {
    a.Swap(&b);
  }

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

  inline TRANS_TBL* New() const final {
    return CreateMaybeMessage<TRANS_TBL>(nullptr);
  }

  TRANS_TBL* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TRANS_TBL>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TRANS_TBL& from);
  void MergeFrom(const TRANS_TBL& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TRANS_TBL* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.TRANS_TBL";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // .pb.transformation trans = 2;
  bool has_trans() const;
  void clear_trans();
  static const int kTransFieldNumber = 2;
  const ::pb::transformation& trans() const;
  ::pb::transformation* release_trans();
  ::pb::transformation* mutable_trans();
  void set_allocated_trans(::pb::transformation* trans);

  // uint64 trans_address = 1;
  void clear_trans_address();
  static const int kTransAddressFieldNumber = 1;
  ::PROTOBUF_NAMESPACE_ID::uint64 trans_address() const;
  void set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:pb.TRANS_TBL)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::pb::transformation* trans_;
  ::PROTOBUF_NAMESPACE_ID::uint64 trans_address_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// -------------------------------------------------------------------

class GatingSet :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.GatingSet) */ {
 public:
  GatingSet();
  virtual ~GatingSet();

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

  inline GatingSet& operator=(const GatingSet& from) {
    CopyFrom(from);
    return *this;
  }
  inline GatingSet& operator=(GatingSet&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GatingSet& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GatingSet* internal_default_instance() {
    return reinterpret_cast<const GatingSet*>(
               &_GatingSet_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  void Swap(GatingSet* other);
  friend void swap(GatingSet& a, GatingSet& b) {
    a.Swap(&b);
  }

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

  inline GatingSet* New() const final {
    return CreateMaybeMessage<GatingSet>(nullptr);
  }

  GatingSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GatingSet>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GatingSet& from);
  void MergeFrom(const GatingSet& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GatingSet* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.GatingSet";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto);
    return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  // repeated string sampleName = 1;
  int samplename_size() const;
  void clear_samplename();
  static const int kSampleNameFieldNumber = 1;
  const std::string& samplename(int index) const;
  std::string* mutable_samplename(int index);
  void set_samplename(int index, const std::string& value);
  void set_samplename(int index, std::string&& value);
  void set_samplename(int index, const char* value);
  void set_samplename(int index, const char* value, size_t size);
  std::string* add_samplename();
  void add_samplename(const std::string& value);
  void add_samplename(std::string&& value);
  void add_samplename(const char* value);
  void add_samplename(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& samplename() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_samplename();

  // repeated .pb.TRANS_TBL trans_tbl = 2;
  int trans_tbl_size() const;
  void clear_trans_tbl();
  static const int kTransTblFieldNumber = 2;
  ::pb::TRANS_TBL* mutable_trans_tbl(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >*
      mutable_trans_tbl();
  const ::pb::TRANS_TBL& trans_tbl(int index) const;
  ::pb::TRANS_TBL* add_trans_tbl();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >&
      trans_tbl() const;

  // repeated .pb.trans_local gTrans = 5;
  int gtrans_size() const;
  void clear_gtrans();
  static const int kGTransFieldNumber = 5;
  ::pb::trans_local* mutable_gtrans(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >*
      mutable_gtrans();
  const ::pb::trans_local& gtrans(int index) const;
  ::pb::trans_local* add_gtrans();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >&
      gtrans() const;

  // string guid = 6;
  void clear_guid();
  static const int kGuidFieldNumber = 6;
  const std::string& guid() const;
  void set_guid(const std::string& value);
  void set_guid(std::string&& value);
  void set_guid(const char* value);
  void set_guid(const char* value, size_t size);
  std::string* mutable_guid();
  std::string* release_guid();
  void set_allocated_guid(std::string* guid);

  // string cytolib_verion = 7;
  void clear_cytolib_verion();
  static const int kCytolibVerionFieldNumber = 7;
  const std::string& cytolib_verion() const;
  void set_cytolib_verion(const std::string& value);
  void set_cytolib_verion(std::string&& value);
  void set_cytolib_verion(const char* value);
  void set_cytolib_verion(const char* value, size_t size);
  std::string* mutable_cytolib_verion();
  std::string* release_cytolib_verion();
  void set_allocated_cytolib_verion(std::string* cytolib_verion);

  // string pb_verion = 8;
  void clear_pb_verion();
  static const int kPbVerionFieldNumber = 8;
  const std::string& pb_verion() const;
  void set_pb_verion(const std::string& value);
  void set_pb_verion(std::string&& value);
  void set_pb_verion(const char* value);
  void set_pb_verion(const char* value, size_t size);
  std::string* mutable_pb_verion();
  std::string* release_pb_verion();
  void set_allocated_pb_verion(std::string* pb_verion);

  // string h5_verion = 9;
  void clear_h5_verion();
  static const int kH5VerionFieldNumber = 9;
  const std::string& h5_verion() const;
  void set_h5_verion(const std::string& value);
  void set_h5_verion(std::string&& value);
  void set_h5_verion(const char* value);
  void set_h5_verion(const char* value, size_t size);
  std::string* mutable_h5_verion();
  std::string* release_h5_verion();
  void set_allocated_h5_verion(std::string* h5_verion);

  // uint64 globalBiExpTrans = 3;
  void clear_globalbiexptrans();
  static const int kGlobalBiExpTransFieldNumber = 3;
  ::PROTOBUF_NAMESPACE_ID::uint64 globalbiexptrans() const;
  void set_globalbiexptrans(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // uint64 globalLinTrans = 4;
  void clear_globallintrans();
  static const int kGlobalLinTransFieldNumber = 4;
  ::PROTOBUF_NAMESPACE_ID::uint64 globallintrans() const;
  void set_globallintrans(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:pb.GatingSet)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> samplename_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL > trans_tbl_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local > gtrans_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr guid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cytolib_verion_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pb_verion_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr h5_verion_;
  ::PROTOBUF_NAMESPACE_ID::uint64 globalbiexptrans_;
  ::PROTOBUF_NAMESPACE_ID::uint64 globallintrans_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_GatingSet_2eproto;
};
// ===================================================================


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

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

// string name = 1;
inline void paramRange::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& paramRange::name() const {
  // @@protoc_insertion_point(field_get:pb.paramRange.name)
  return name_.GetNoArena();
}
inline void paramRange::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.paramRange.name)
}
inline void paramRange::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.paramRange.name)
}
inline void paramRange::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.paramRange.name)
}
inline void paramRange::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.paramRange.name)
}
inline std::string* paramRange::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:pb.paramRange.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* paramRange::release_name() {
  // @@protoc_insertion_point(field_release:pb.paramRange.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void paramRange::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:pb.paramRange.name)
}

// float min = 2;
inline void paramRange::clear_min() {
  min_ = 0;
}
inline float paramRange::min() const {
  // @@protoc_insertion_point(field_get:pb.paramRange.min)
  return min_;
}
inline void paramRange::set_min(float value) {
  
  min_ = value;
  // @@protoc_insertion_point(field_set:pb.paramRange.min)
}

// float max = 3;
inline void paramRange::clear_max() {
  max_ = 0;
}
inline float paramRange::max() const {
  // @@protoc_insertion_point(field_get:pb.paramRange.max)
  return max_;
}
inline void paramRange::set_max(float value) {
  
  max_ = value;
  // @@protoc_insertion_point(field_set:pb.paramRange.max)
}

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

// rangeGate

// .pb.paramRange param = 1;
inline bool rangeGate::has_param() const {
  return this != internal_default_instance() && param_ != nullptr;
}
inline void rangeGate::clear_param() {
  if (GetArenaNoVirtual() == nullptr && param_ != nullptr) {
    delete param_;
  }
  param_ = nullptr;
}
inline const ::pb::paramRange& rangeGate::param() const {
  const ::pb::paramRange* p = param_;
  // @@protoc_insertion_point(field_get:pb.rangeGate.param)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::paramRange*>(
      &::pb::_paramRange_default_instance_);
}
inline ::pb::paramRange* rangeGate::release_param() {
  // @@protoc_insertion_point(field_release:pb.rangeGate.param)
  
  ::pb::paramRange* temp = param_;
  param_ = nullptr;
  return temp;
}
inline ::pb::paramRange* rangeGate::mutable_param() {
  
  if (param_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::paramRange>(GetArenaNoVirtual());
    param_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.rangeGate.param)
  return param_;
}
inline void rangeGate::set_allocated_param(::pb::paramRange* param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete param_;
  }
  if (param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, param, submessage_arena);
    }
    
  } else {
    
  }
  param_ = param;
  // @@protoc_insertion_point(field_set_allocated:pb.rangeGate.param)
}

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

// paramPoly

// repeated string params = 1;
inline int paramPoly::params_size() const {
  return params_.size();
}
inline void paramPoly::clear_params() {
  params_.Clear();
}
inline const std::string& paramPoly::params(int index) const {
  // @@protoc_insertion_point(field_get:pb.paramPoly.params)
  return params_.Get(index);
}
inline std::string* paramPoly::mutable_params(int index) {
  // @@protoc_insertion_point(field_mutable:pb.paramPoly.params)
  return params_.Mutable(index);
}
inline void paramPoly::set_params(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.paramPoly.params)
  params_.Mutable(index)->assign(value);
}
inline void paramPoly::set_params(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.paramPoly.params)
  params_.Mutable(index)->assign(std::move(value));
}
inline void paramPoly::set_params(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  params_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.paramPoly.params)
}
inline void paramPoly::set_params(int index, const char* value, size_t size) {
  params_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.paramPoly.params)
}
inline std::string* paramPoly::add_params() {
  // @@protoc_insertion_point(field_add_mutable:pb.paramPoly.params)
  return params_.Add();
}
inline void paramPoly::add_params(const std::string& value) {
  params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.paramPoly.params)
}
inline void paramPoly::add_params(std::string&& value) {
  params_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.paramPoly.params)
}
inline void paramPoly::add_params(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.paramPoly.params)
}
inline void paramPoly::add_params(const char* value, size_t size) {
  params_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.paramPoly.params)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
paramPoly::params() const {
  // @@protoc_insertion_point(field_list:pb.paramPoly.params)
  return params_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
paramPoly::mutable_params() {
  // @@protoc_insertion_point(field_mutable_list:pb.paramPoly.params)
  return &params_;
}

// repeated .pb.coordinate vertices = 2;
inline int paramPoly::vertices_size() const {
  return vertices_.size();
}
inline void paramPoly::clear_vertices() {
  vertices_.Clear();
}
inline ::pb::coordinate* paramPoly::mutable_vertices(int index) {
  // @@protoc_insertion_point(field_mutable:pb.paramPoly.vertices)
  return vertices_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >*
paramPoly::mutable_vertices() {
  // @@protoc_insertion_point(field_mutable_list:pb.paramPoly.vertices)
  return &vertices_;
}
inline const ::pb::coordinate& paramPoly::vertices(int index) const {
  // @@protoc_insertion_point(field_get:pb.paramPoly.vertices)
  return vertices_.Get(index);
}
inline ::pb::coordinate* paramPoly::add_vertices() {
  // @@protoc_insertion_point(field_add:pb.paramPoly.vertices)
  return vertices_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >&
paramPoly::vertices() const {
  // @@protoc_insertion_point(field_list:pb.paramPoly.vertices)
  return vertices_;
}

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

// polygonGate

// .pb.paramPoly param = 1;
inline bool polygonGate::has_param() const {
  return this != internal_default_instance() && param_ != nullptr;
}
inline void polygonGate::clear_param() {
  if (GetArenaNoVirtual() == nullptr && param_ != nullptr) {
    delete param_;
  }
  param_ = nullptr;
}
inline const ::pb::paramPoly& polygonGate::param() const {
  const ::pb::paramPoly* p = param_;
  // @@protoc_insertion_point(field_get:pb.polygonGate.param)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::paramPoly*>(
      &::pb::_paramPoly_default_instance_);
}
inline ::pb::paramPoly* polygonGate::release_param() {
  // @@protoc_insertion_point(field_release:pb.polygonGate.param)
  
  ::pb::paramPoly* temp = param_;
  param_ = nullptr;
  return temp;
}
inline ::pb::paramPoly* polygonGate::mutable_param() {
  
  if (param_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::paramPoly>(GetArenaNoVirtual());
    param_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.polygonGate.param)
  return param_;
}
inline void polygonGate::set_allocated_param(::pb::paramPoly* param) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete param_;
  }
  if (param) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, param, submessage_arena);
    }
    
  } else {
    
  }
  param_ = param;
  // @@protoc_insertion_point(field_set_allocated:pb.polygonGate.param)
}

// .pb.quadGate qg = 2;
inline bool polygonGate::has_qg() const {
  return this != internal_default_instance() && qg_ != nullptr;
}
inline void polygonGate::clear_qg() {
  if (GetArenaNoVirtual() == nullptr && qg_ != nullptr) {
    delete qg_;
  }
  qg_ = nullptr;
}
inline const ::pb::quadGate& polygonGate::qg() const {
  const ::pb::quadGate* p = qg_;
  // @@protoc_insertion_point(field_get:pb.polygonGate.qg)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::quadGate*>(
      &::pb::_quadGate_default_instance_);
}
inline ::pb::quadGate* polygonGate::release_qg() {
  // @@protoc_insertion_point(field_release:pb.polygonGate.qg)
  
  ::pb::quadGate* temp = qg_;
  qg_ = nullptr;
  return temp;
}
inline ::pb::quadGate* polygonGate::mutable_qg() {
  
  if (qg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::quadGate>(GetArenaNoVirtual());
    qg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.polygonGate.qg)
  return qg_;
}
inline void polygonGate::set_allocated_qg(::pb::quadGate* qg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete qg_;
  }
  if (qg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      qg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, qg, submessage_arena);
    }
    
  } else {
    
  }
  qg_ = qg;
  // @@protoc_insertion_point(field_set_allocated:pb.polygonGate.qg)
}

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

// coordinate

// float x = 1;
inline void coordinate::clear_x() {
  x_ = 0;
}
inline float coordinate::x() const {
  // @@protoc_insertion_point(field_get:pb.coordinate.x)
  return x_;
}
inline void coordinate::set_x(float value) {
  
  x_ = value;
  // @@protoc_insertion_point(field_set:pb.coordinate.x)
}

// float y = 2;
inline void coordinate::clear_y() {
  y_ = 0;
}
inline float coordinate::y() const {
  // @@protoc_insertion_point(field_get:pb.coordinate.y)
  return y_;
}
inline void coordinate::set_y(float value) {
  
  y_ = value;
  // @@protoc_insertion_point(field_set:pb.coordinate.y)
}

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

// ellipseGate

// .pb.coordinate mu = 1;
inline bool ellipseGate::has_mu() const {
  return this != internal_default_instance() && mu_ != nullptr;
}
inline void ellipseGate::clear_mu() {
  if (GetArenaNoVirtual() == nullptr && mu_ != nullptr) {
    delete mu_;
  }
  mu_ = nullptr;
}
inline const ::pb::coordinate& ellipseGate::mu() const {
  const ::pb::coordinate* p = mu_;
  // @@protoc_insertion_point(field_get:pb.ellipseGate.mu)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::coordinate*>(
      &::pb::_coordinate_default_instance_);
}
inline ::pb::coordinate* ellipseGate::release_mu() {
  // @@protoc_insertion_point(field_release:pb.ellipseGate.mu)
  
  ::pb::coordinate* temp = mu_;
  mu_ = nullptr;
  return temp;
}
inline ::pb::coordinate* ellipseGate::mutable_mu() {
  
  if (mu_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::coordinate>(GetArenaNoVirtual());
    mu_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.ellipseGate.mu)
  return mu_;
}
inline void ellipseGate::set_allocated_mu(::pb::coordinate* mu) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete mu_;
  }
  if (mu) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      mu = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mu, submessage_arena);
    }
    
  } else {
    
  }
  mu_ = mu;
  // @@protoc_insertion_point(field_set_allocated:pb.ellipseGate.mu)
}

// repeated .pb.coordinate cov = 2;
inline int ellipseGate::cov_size() const {
  return cov_.size();
}
inline void ellipseGate::clear_cov() {
  cov_.Clear();
}
inline ::pb::coordinate* ellipseGate::mutable_cov(int index) {
  // @@protoc_insertion_point(field_mutable:pb.ellipseGate.cov)
  return cov_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >*
ellipseGate::mutable_cov() {
  // @@protoc_insertion_point(field_mutable_list:pb.ellipseGate.cov)
  return &cov_;
}
inline const ::pb::coordinate& ellipseGate::cov(int index) const {
  // @@protoc_insertion_point(field_get:pb.ellipseGate.cov)
  return cov_.Get(index);
}
inline ::pb::coordinate* ellipseGate::add_cov() {
  // @@protoc_insertion_point(field_add:pb.ellipseGate.cov)
  return cov_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >&
ellipseGate::cov() const {
  // @@protoc_insertion_point(field_list:pb.ellipseGate.cov)
  return cov_;
}

// repeated .pb.coordinate antipodal_vertices = 3;
inline int ellipseGate::antipodal_vertices_size() const {
  return antipodal_vertices_.size();
}
inline void ellipseGate::clear_antipodal_vertices() {
  antipodal_vertices_.Clear();
}
inline ::pb::coordinate* ellipseGate::mutable_antipodal_vertices(int index) {
  // @@protoc_insertion_point(field_mutable:pb.ellipseGate.antipodal_vertices)
  return antipodal_vertices_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >*
ellipseGate::mutable_antipodal_vertices() {
  // @@protoc_insertion_point(field_mutable_list:pb.ellipseGate.antipodal_vertices)
  return &antipodal_vertices_;
}
inline const ::pb::coordinate& ellipseGate::antipodal_vertices(int index) const {
  // @@protoc_insertion_point(field_get:pb.ellipseGate.antipodal_vertices)
  return antipodal_vertices_.Get(index);
}
inline ::pb::coordinate* ellipseGate::add_antipodal_vertices() {
  // @@protoc_insertion_point(field_add:pb.ellipseGate.antipodal_vertices)
  return antipodal_vertices_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >&
ellipseGate::antipodal_vertices() const {
  // @@protoc_insertion_point(field_list:pb.ellipseGate.antipodal_vertices)
  return antipodal_vertices_;
}

// float dist = 4;
inline void ellipseGate::clear_dist() {
  dist_ = 0;
}
inline float ellipseGate::dist() const {
  // @@protoc_insertion_point(field_get:pb.ellipseGate.dist)
  return dist_;
}
inline void ellipseGate::set_dist(float value) {
  
  dist_ = value;
  // @@protoc_insertion_point(field_set:pb.ellipseGate.dist)
}

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

// BOOL_GATE_OP

// repeated string path = 1;
inline int BOOL_GATE_OP::path_size() const {
  return path_.size();
}
inline void BOOL_GATE_OP::clear_path() {
  path_.Clear();
}
inline const std::string& BOOL_GATE_OP::path(int index) const {
  // @@protoc_insertion_point(field_get:pb.BOOL_GATE_OP.path)
  return path_.Get(index);
}
inline std::string* BOOL_GATE_OP::mutable_path(int index) {
  // @@protoc_insertion_point(field_mutable:pb.BOOL_GATE_OP.path)
  return path_.Mutable(index);
}
inline void BOOL_GATE_OP::set_path(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.path)
  path_.Mutable(index)->assign(value);
}
inline void BOOL_GATE_OP::set_path(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.path)
  path_.Mutable(index)->assign(std::move(value));
}
inline void BOOL_GATE_OP::set_path(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  path_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.BOOL_GATE_OP.path)
}
inline void BOOL_GATE_OP::set_path(int index, const char* value, size_t size) {
  path_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.BOOL_GATE_OP.path)
}
inline std::string* BOOL_GATE_OP::add_path() {
  // @@protoc_insertion_point(field_add_mutable:pb.BOOL_GATE_OP.path)
  return path_.Add();
}
inline void BOOL_GATE_OP::add_path(const std::string& value) {
  path_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.BOOL_GATE_OP.path)
}
inline void BOOL_GATE_OP::add_path(std::string&& value) {
  path_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.BOOL_GATE_OP.path)
}
inline void BOOL_GATE_OP::add_path(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  path_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.BOOL_GATE_OP.path)
}
inline void BOOL_GATE_OP::add_path(const char* value, size_t size) {
  path_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.BOOL_GATE_OP.path)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BOOL_GATE_OP::path() const {
  // @@protoc_insertion_point(field_list:pb.BOOL_GATE_OP.path)
  return path_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BOOL_GATE_OP::mutable_path() {
  // @@protoc_insertion_point(field_mutable_list:pb.BOOL_GATE_OP.path)
  return &path_;
}

// uint32 op = 2;
inline void BOOL_GATE_OP::clear_op() {
  op_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 BOOL_GATE_OP::op() const {
  // @@protoc_insertion_point(field_get:pb.BOOL_GATE_OP.op)
  return op_;
}
inline void BOOL_GATE_OP::set_op(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  op_ = value;
  // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.op)
}

// bool isNot = 3;
inline void BOOL_GATE_OP::clear_isnot() {
  isnot_ = false;
}
inline bool BOOL_GATE_OP::isnot() const {
  // @@protoc_insertion_point(field_get:pb.BOOL_GATE_OP.isNot)
  return isnot_;
}
inline void BOOL_GATE_OP::set_isnot(bool value) {
  
  isnot_ = value;
  // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.isNot)
}

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

// boolGate

// repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
inline int boolGate::boolopspec_size() const {
  return boolopspec_.size();
}
inline void boolGate::clear_boolopspec() {
  boolopspec_.Clear();
}
inline ::pb::BOOL_GATE_OP* boolGate::mutable_boolopspec(int index) {
  // @@protoc_insertion_point(field_mutable:pb.boolGate.boolOpSpec)
  return boolopspec_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >*
boolGate::mutable_boolopspec() {
  // @@protoc_insertion_point(field_mutable_list:pb.boolGate.boolOpSpec)
  return &boolopspec_;
}
inline const ::pb::BOOL_GATE_OP& boolGate::boolopspec(int index) const {
  // @@protoc_insertion_point(field_get:pb.boolGate.boolOpSpec)
  return boolopspec_.Get(index);
}
inline ::pb::BOOL_GATE_OP* boolGate::add_boolopspec() {
  // @@protoc_insertion_point(field_add:pb.boolGate.boolOpSpec)
  return boolopspec_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >&
boolGate::boolopspec() const {
  // @@protoc_insertion_point(field_list:pb.boolGate.boolOpSpec)
  return boolopspec_;
}

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

// clusterGate

// string cluster_method = 1;
inline void clusterGate::clear_cluster_method() {
  cluster_method_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& clusterGate::cluster_method() const {
  // @@protoc_insertion_point(field_get:pb.clusterGate.cluster_method)
  return cluster_method_.GetNoArena();
}
inline void clusterGate::set_cluster_method(const std::string& value) {
  
  cluster_method_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.clusterGate.cluster_method)
}
inline void clusterGate::set_cluster_method(std::string&& value) {
  
  cluster_method_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.clusterGate.cluster_method)
}
inline void clusterGate::set_cluster_method(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cluster_method_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.clusterGate.cluster_method)
}
inline void clusterGate::set_cluster_method(const char* value, size_t size) {
  
  cluster_method_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.clusterGate.cluster_method)
}
inline std::string* clusterGate::mutable_cluster_method() {
  
  // @@protoc_insertion_point(field_mutable:pb.clusterGate.cluster_method)
  return cluster_method_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* clusterGate::release_cluster_method() {
  // @@protoc_insertion_point(field_release:pb.clusterGate.cluster_method)
  
  return cluster_method_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void clusterGate::set_allocated_cluster_method(std::string* cluster_method) {
  if (cluster_method != nullptr) {
    
  } else {
    
  }
  cluster_method_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cluster_method);
  // @@protoc_insertion_point(field_set_allocated:pb.clusterGate.cluster_method)
}

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

// quadGate

// string uid = 1;
inline void quadGate::clear_uid() {
  uid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& quadGate::uid() const {
  // @@protoc_insertion_point(field_get:pb.quadGate.uid)
  return uid_.GetNoArena();
}
inline void quadGate::set_uid(const std::string& value) {
  
  uid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.quadGate.uid)
}
inline void quadGate::set_uid(std::string&& value) {
  
  uid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.quadGate.uid)
}
inline void quadGate::set_uid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.quadGate.uid)
}
inline void quadGate::set_uid(const char* value, size_t size) {
  
  uid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.quadGate.uid)
}
inline std::string* quadGate::mutable_uid() {
  
  // @@protoc_insertion_point(field_mutable:pb.quadGate.uid)
  return uid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* quadGate::release_uid() {
  // @@protoc_insertion_point(field_release:pb.quadGate.uid)
  
  return uid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void quadGate::set_allocated_uid(std::string* uid) {
  if (uid != nullptr) {
    
  } else {
    
  }
  uid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uid);
  // @@protoc_insertion_point(field_set_allocated:pb.quadGate.uid)
}

// .pb.QUADRANT quadrant = 3;
inline void quadGate::clear_quadrant() {
  quadrant_ = 0;
}
inline ::pb::QUADRANT quadGate::quadrant() const {
  // @@protoc_insertion_point(field_get:pb.quadGate.quadrant)
  return static_cast< ::pb::QUADRANT >(quadrant_);
}
inline void quadGate::set_quadrant(::pb::QUADRANT value) {
  
  quadrant_ = value;
  // @@protoc_insertion_point(field_set:pb.quadGate.quadrant)
}

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

// gate

// bool neg = 1;
inline void gate::clear_neg() {
  neg_ = false;
}
inline bool gate::neg() const {
  // @@protoc_insertion_point(field_get:pb.gate.neg)
  return neg_;
}
inline void gate::set_neg(bool value) {
  
  neg_ = value;
  // @@protoc_insertion_point(field_set:pb.gate.neg)
}

// bool isTransformed = 2;
inline void gate::clear_istransformed() {
  istransformed_ = false;
}
inline bool gate::istransformed() const {
  // @@protoc_insertion_point(field_get:pb.gate.isTransformed)
  return istransformed_;
}
inline void gate::set_istransformed(bool value) {
  
  istransformed_ = value;
  // @@protoc_insertion_point(field_set:pb.gate.isTransformed)
}

// bool isGained = 3;
inline void gate::clear_isgained() {
  isgained_ = false;
}
inline bool gate::isgained() const {
  // @@protoc_insertion_point(field_get:pb.gate.isGained)
  return isgained_;
}
inline void gate::set_isgained(bool value) {
  
  isgained_ = value;
  // @@protoc_insertion_point(field_set:pb.gate.isGained)
}

// .pb.GATE_TYPE type = 4;
inline void gate::clear_type() {
  type_ = 0;
}
inline ::pb::GATE_TYPE gate::type() const {
  // @@protoc_insertion_point(field_get:pb.gate.type)
  return static_cast< ::pb::GATE_TYPE >(type_);
}
inline void gate::set_type(::pb::GATE_TYPE value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:pb.gate.type)
}

// .pb.rangeGate rg = 5;
inline bool gate::has_rg() const {
  return this != internal_default_instance() && rg_ != nullptr;
}
inline void gate::clear_rg() {
  if (GetArenaNoVirtual() == nullptr && rg_ != nullptr) {
    delete rg_;
  }
  rg_ = nullptr;
}
inline const ::pb::rangeGate& gate::rg() const {
  const ::pb::rangeGate* p = rg_;
  // @@protoc_insertion_point(field_get:pb.gate.rg)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::rangeGate*>(
      &::pb::_rangeGate_default_instance_);
}
inline ::pb::rangeGate* gate::release_rg() {
  // @@protoc_insertion_point(field_release:pb.gate.rg)
  
  ::pb::rangeGate* temp = rg_;
  rg_ = nullptr;
  return temp;
}
inline ::pb::rangeGate* gate::mutable_rg() {
  
  if (rg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::rangeGate>(GetArenaNoVirtual());
    rg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.gate.rg)
  return rg_;
}
inline void gate::set_allocated_rg(::pb::rangeGate* rg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete rg_;
  }
  if (rg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      rg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rg, submessage_arena);
    }
    
  } else {
    
  }
  rg_ = rg;
  // @@protoc_insertion_point(field_set_allocated:pb.gate.rg)
}

// .pb.polygonGate pg = 6;
inline bool gate::has_pg() const {
  return this != internal_default_instance() && pg_ != nullptr;
}
inline void gate::clear_pg() {
  if (GetArenaNoVirtual() == nullptr && pg_ != nullptr) {
    delete pg_;
  }
  pg_ = nullptr;
}
inline const ::pb::polygonGate& gate::pg() const {
  const ::pb::polygonGate* p = pg_;
  // @@protoc_insertion_point(field_get:pb.gate.pg)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::polygonGate*>(
      &::pb::_polygonGate_default_instance_);
}
inline ::pb::polygonGate* gate::release_pg() {
  // @@protoc_insertion_point(field_release:pb.gate.pg)
  
  ::pb::polygonGate* temp = pg_;
  pg_ = nullptr;
  return temp;
}
inline ::pb::polygonGate* gate::mutable_pg() {
  
  if (pg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::polygonGate>(GetArenaNoVirtual());
    pg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.gate.pg)
  return pg_;
}
inline void gate::set_allocated_pg(::pb::polygonGate* pg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete pg_;
  }
  if (pg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      pg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pg, submessage_arena);
    }
    
  } else {
    
  }
  pg_ = pg;
  // @@protoc_insertion_point(field_set_allocated:pb.gate.pg)
}

// .pb.ellipseGate eg = 7;
inline bool gate::has_eg() const {
  return this != internal_default_instance() && eg_ != nullptr;
}
inline void gate::clear_eg() {
  if (GetArenaNoVirtual() == nullptr && eg_ != nullptr) {
    delete eg_;
  }
  eg_ = nullptr;
}
inline const ::pb::ellipseGate& gate::eg() const {
  const ::pb::ellipseGate* p = eg_;
  // @@protoc_insertion_point(field_get:pb.gate.eg)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::ellipseGate*>(
      &::pb::_ellipseGate_default_instance_);
}
inline ::pb::ellipseGate* gate::release_eg() {
  // @@protoc_insertion_point(field_release:pb.gate.eg)
  
  ::pb::ellipseGate* temp = eg_;
  eg_ = nullptr;
  return temp;
}
inline ::pb::ellipseGate* gate::mutable_eg() {
  
  if (eg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::ellipseGate>(GetArenaNoVirtual());
    eg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.gate.eg)
  return eg_;
}
inline void gate::set_allocated_eg(::pb::ellipseGate* eg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete eg_;
  }
  if (eg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      eg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, eg, submessage_arena);
    }
    
  } else {
    
  }
  eg_ = eg;
  // @@protoc_insertion_point(field_set_allocated:pb.gate.eg)
}

// .pb.boolGate bg = 8;
inline bool gate::has_bg() const {
  return this != internal_default_instance() && bg_ != nullptr;
}
inline void gate::clear_bg() {
  if (GetArenaNoVirtual() == nullptr && bg_ != nullptr) {
    delete bg_;
  }
  bg_ = nullptr;
}
inline const ::pb::boolGate& gate::bg() const {
  const ::pb::boolGate* p = bg_;
  // @@protoc_insertion_point(field_get:pb.gate.bg)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::boolGate*>(
      &::pb::_boolGate_default_instance_);
}
inline ::pb::boolGate* gate::release_bg() {
  // @@protoc_insertion_point(field_release:pb.gate.bg)
  
  ::pb::boolGate* temp = bg_;
  bg_ = nullptr;
  return temp;
}
inline ::pb::boolGate* gate::mutable_bg() {
  
  if (bg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::boolGate>(GetArenaNoVirtual());
    bg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.gate.bg)
  return bg_;
}
inline void gate::set_allocated_bg(::pb::boolGate* bg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete bg_;
  }
  if (bg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      bg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bg, submessage_arena);
    }
    
  } else {
    
  }
  bg_ = bg;
  // @@protoc_insertion_point(field_set_allocated:pb.gate.bg)
}

// .pb.clusterGate cg = 9;
inline bool gate::has_cg() const {
  return this != internal_default_instance() && cg_ != nullptr;
}
inline void gate::clear_cg() {
  if (GetArenaNoVirtual() == nullptr && cg_ != nullptr) {
    delete cg_;
  }
  cg_ = nullptr;
}
inline const ::pb::clusterGate& gate::cg() const {
  const ::pb::clusterGate* p = cg_;
  // @@protoc_insertion_point(field_get:pb.gate.cg)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::clusterGate*>(
      &::pb::_clusterGate_default_instance_);
}
inline ::pb::clusterGate* gate::release_cg() {
  // @@protoc_insertion_point(field_release:pb.gate.cg)
  
  ::pb::clusterGate* temp = cg_;
  cg_ = nullptr;
  return temp;
}
inline ::pb::clusterGate* gate::mutable_cg() {
  
  if (cg_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::clusterGate>(GetArenaNoVirtual());
    cg_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.gate.cg)
  return cg_;
}
inline void gate::set_allocated_cg(::pb::clusterGate* cg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete cg_;
  }
  if (cg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cg, submessage_arena);
    }
    
  } else {
    
  }
  cg_ = cg;
  // @@protoc_insertion_point(field_set_allocated:pb.gate.cg)
}

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

// POPSTATS

// string statType = 1;
inline void POPSTATS::clear_stattype() {
  stattype_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& POPSTATS::stattype() const {
  // @@protoc_insertion_point(field_get:pb.POPSTATS.statType)
  return stattype_.GetNoArena();
}
inline void POPSTATS::set_stattype(const std::string& value) {
  
  stattype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.POPSTATS.statType)
}
inline void POPSTATS::set_stattype(std::string&& value) {
  
  stattype_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.POPSTATS.statType)
}
inline void POPSTATS::set_stattype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  stattype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.POPSTATS.statType)
}
inline void POPSTATS::set_stattype(const char* value, size_t size) {
  
  stattype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.POPSTATS.statType)
}
inline std::string* POPSTATS::mutable_stattype() {
  
  // @@protoc_insertion_point(field_mutable:pb.POPSTATS.statType)
  return stattype_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* POPSTATS::release_stattype() {
  // @@protoc_insertion_point(field_release:pb.POPSTATS.statType)
  
  return stattype_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void POPSTATS::set_allocated_stattype(std::string* stattype) {
  if (stattype != nullptr) {
    
  } else {
    
  }
  stattype_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stattype);
  // @@protoc_insertion_point(field_set_allocated:pb.POPSTATS.statType)
}

// float statVal = 2;
inline void POPSTATS::clear_statval() {
  statval_ = 0;
}
inline float POPSTATS::statval() const {
  // @@protoc_insertion_point(field_get:pb.POPSTATS.statVal)
  return statval_;
}
inline void POPSTATS::set_statval(float value) {
  
  statval_ = value;
  // @@protoc_insertion_point(field_set:pb.POPSTATS.statVal)
}

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

// calibrationTable

// repeated float x = 1 [packed = true];
inline int calibrationTable::x_size() const {
  return x_.size();
}
inline void calibrationTable::clear_x() {
  x_.Clear();
}
inline float calibrationTable::x(int index) const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.x)
  return x_.Get(index);
}
inline void calibrationTable::set_x(int index, float value) {
  x_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.calibrationTable.x)
}
inline void calibrationTable::add_x(float value) {
  x_.Add(value);
  // @@protoc_insertion_point(field_add:pb.calibrationTable.x)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
calibrationTable::x() const {
  // @@protoc_insertion_point(field_list:pb.calibrationTable.x)
  return x_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
calibrationTable::mutable_x() {
  // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.x)
  return &x_;
}

// repeated float y = 2 [packed = true];
inline int calibrationTable::y_size() const {
  return y_.size();
}
inline void calibrationTable::clear_y() {
  y_.Clear();
}
inline float calibrationTable::y(int index) const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.y)
  return y_.Get(index);
}
inline void calibrationTable::set_y(int index, float value) {
  y_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.calibrationTable.y)
}
inline void calibrationTable::add_y(float value) {
  y_.Add(value);
  // @@protoc_insertion_point(field_add:pb.calibrationTable.y)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
calibrationTable::y() const {
  // @@protoc_insertion_point(field_list:pb.calibrationTable.y)
  return y_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
calibrationTable::mutable_y() {
  // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.y)
  return &y_;
}

// repeated float b = 3 [packed = true];
inline int calibrationTable::b_size() const {
  return b_.size();
}
inline void calibrationTable::clear_b() {
  b_.Clear();
}
inline float calibrationTable::b(int index) const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.b)
  return b_.Get(index);
}
inline void calibrationTable::set_b(int index, float value) {
  b_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.calibrationTable.b)
}
inline void calibrationTable::add_b(float value) {
  b_.Add(value);
  // @@protoc_insertion_point(field_add:pb.calibrationTable.b)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
calibrationTable::b() const {
  // @@protoc_insertion_point(field_list:pb.calibrationTable.b)
  return b_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
calibrationTable::mutable_b() {
  // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.b)
  return &b_;
}

// repeated float c = 4 [packed = true];
inline int calibrationTable::c_size() const {
  return c_.size();
}
inline void calibrationTable::clear_c() {
  c_.Clear();
}
inline float calibrationTable::c(int index) const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.c)
  return c_.Get(index);
}
inline void calibrationTable::set_c(int index, float value) {
  c_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.calibrationTable.c)
}
inline void calibrationTable::add_c(float value) {
  c_.Add(value);
  // @@protoc_insertion_point(field_add:pb.calibrationTable.c)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
calibrationTable::c() const {
  // @@protoc_insertion_point(field_list:pb.calibrationTable.c)
  return c_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
calibrationTable::mutable_c() {
  // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.c)
  return &c_;
}

// repeated float d = 5 [packed = true];
inline int calibrationTable::d_size() const {
  return d_.size();
}
inline void calibrationTable::clear_d() {
  d_.Clear();
}
inline float calibrationTable::d(int index) const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.d)
  return d_.Get(index);
}
inline void calibrationTable::set_d(int index, float value) {
  d_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.calibrationTable.d)
}
inline void calibrationTable::add_d(float value) {
  d_.Add(value);
  // @@protoc_insertion_point(field_add:pb.calibrationTable.d)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
calibrationTable::d() const {
  // @@protoc_insertion_point(field_list:pb.calibrationTable.d)
  return d_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
calibrationTable::mutable_d() {
  // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.d)
  return &d_;
}

// uint32 spline_method = 6;
inline void calibrationTable::clear_spline_method() {
  spline_method_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 calibrationTable::spline_method() const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.spline_method)
  return spline_method_;
}
inline void calibrationTable::set_spline_method(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  spline_method_ = value;
  // @@protoc_insertion_point(field_set:pb.calibrationTable.spline_method)
}

// string caltype = 7;
inline void calibrationTable::clear_caltype() {
  caltype_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& calibrationTable::caltype() const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.caltype)
  return caltype_.GetNoArena();
}
inline void calibrationTable::set_caltype(const std::string& value) {
  
  caltype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.calibrationTable.caltype)
}
inline void calibrationTable::set_caltype(std::string&& value) {
  
  caltype_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.calibrationTable.caltype)
}
inline void calibrationTable::set_caltype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  caltype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.calibrationTable.caltype)
}
inline void calibrationTable::set_caltype(const char* value, size_t size) {
  
  caltype_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.calibrationTable.caltype)
}
inline std::string* calibrationTable::mutable_caltype() {
  
  // @@protoc_insertion_point(field_mutable:pb.calibrationTable.caltype)
  return caltype_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* calibrationTable::release_caltype() {
  // @@protoc_insertion_point(field_release:pb.calibrationTable.caltype)
  
  return caltype_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void calibrationTable::set_allocated_caltype(std::string* caltype) {
  if (caltype != nullptr) {
    
  } else {
    
  }
  caltype_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), caltype);
  // @@protoc_insertion_point(field_set_allocated:pb.calibrationTable.caltype)
}

// bool flag = 8;
inline void calibrationTable::clear_flag() {
  flag_ = false;
}
inline bool calibrationTable::flag() const {
  // @@protoc_insertion_point(field_get:pb.calibrationTable.flag)
  return flag_;
}
inline void calibrationTable::set_flag(bool value) {
  
  flag_ = value;
  // @@protoc_insertion_point(field_set:pb.calibrationTable.flag)
}

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

// biexpTrans

// uint32 channelRange = 1;
inline void biexpTrans::clear_channelrange() {
  channelrange_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 biexpTrans::channelrange() const {
  // @@protoc_insertion_point(field_get:pb.biexpTrans.channelRange)
  return channelrange_;
}
inline void biexpTrans::set_channelrange(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  channelrange_ = value;
  // @@protoc_insertion_point(field_set:pb.biexpTrans.channelRange)
}

// float pos = 2;
inline void biexpTrans::clear_pos() {
  pos_ = 0;
}
inline float biexpTrans::pos() const {
  // @@protoc_insertion_point(field_get:pb.biexpTrans.pos)
  return pos_;
}
inline void biexpTrans::set_pos(float value) {
  
  pos_ = value;
  // @@protoc_insertion_point(field_set:pb.biexpTrans.pos)
}

// float neg = 3;
inline void biexpTrans::clear_neg() {
  neg_ = 0;
}
inline float biexpTrans::neg() const {
  // @@protoc_insertion_point(field_get:pb.biexpTrans.neg)
  return neg_;
}
inline void biexpTrans::set_neg(float value) {
  
  neg_ = value;
  // @@protoc_insertion_point(field_set:pb.biexpTrans.neg)
}

// float widthBasis = 4;
inline void biexpTrans::clear_widthbasis() {
  widthbasis_ = 0;
}
inline float biexpTrans::widthbasis() const {
  // @@protoc_insertion_point(field_get:pb.biexpTrans.widthBasis)
  return widthbasis_;
}
inline void biexpTrans::set_widthbasis(float value) {
  
  widthbasis_ = value;
  // @@protoc_insertion_point(field_set:pb.biexpTrans.widthBasis)
}

// float maxValue = 5;
inline void biexpTrans::clear_maxvalue() {
  maxvalue_ = 0;
}
inline float biexpTrans::maxvalue() const {
  // @@protoc_insertion_point(field_get:pb.biexpTrans.maxValue)
  return maxvalue_;
}
inline void biexpTrans::set_maxvalue(float value) {
  
  maxvalue_ = value;
  // @@protoc_insertion_point(field_set:pb.biexpTrans.maxValue)
}

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

// fasinhTrans

// float length = 1;
inline void fasinhTrans::clear_length() {
  length_ = 0;
}
inline float fasinhTrans::length() const {
  // @@protoc_insertion_point(field_get:pb.fasinhTrans.length)
  return length_;
}
inline void fasinhTrans::set_length(float value) {
  
  length_ = value;
  // @@protoc_insertion_point(field_set:pb.fasinhTrans.length)
}

// float maxRange = 2;
inline void fasinhTrans::clear_maxrange() {
  maxrange_ = 0;
}
inline float fasinhTrans::maxrange() const {
  // @@protoc_insertion_point(field_get:pb.fasinhTrans.maxRange)
  return maxrange_;
}
inline void fasinhTrans::set_maxrange(float value) {
  
  maxrange_ = value;
  // @@protoc_insertion_point(field_set:pb.fasinhTrans.maxRange)
}

// float T = 3;
inline void fasinhTrans::clear_t() {
  t_ = 0;
}
inline float fasinhTrans::t() const {
  // @@protoc_insertion_point(field_get:pb.fasinhTrans.T)
  return t_;
}
inline void fasinhTrans::set_t(float value) {
  
  t_ = value;
  // @@protoc_insertion_point(field_set:pb.fasinhTrans.T)
}

// float A = 4;
inline void fasinhTrans::clear_a() {
  a_ = 0;
}
inline float fasinhTrans::a() const {
  // @@protoc_insertion_point(field_get:pb.fasinhTrans.A)
  return a_;
}
inline void fasinhTrans::set_a(float value) {
  
  a_ = value;
  // @@protoc_insertion_point(field_set:pb.fasinhTrans.A)
}

// float M = 5;
inline void fasinhTrans::clear_m() {
  m_ = 0;
}
inline float fasinhTrans::m() const {
  // @@protoc_insertion_point(field_get:pb.fasinhTrans.M)
  return m_;
}
inline void fasinhTrans::set_m(float value) {
  
  m_ = value;
  // @@protoc_insertion_point(field_set:pb.fasinhTrans.M)
}

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

// scaleTrans

// float scale_factor = 1;
inline void scaleTrans::clear_scale_factor() {
  scale_factor_ = 0;
}
inline float scaleTrans::scale_factor() const {
  // @@protoc_insertion_point(field_get:pb.scaleTrans.scale_factor)
  return scale_factor_;
}
inline void scaleTrans::set_scale_factor(float value) {
  
  scale_factor_ = value;
  // @@protoc_insertion_point(field_set:pb.scaleTrans.scale_factor)
}

// float t_scale = 2;
inline void scaleTrans::clear_t_scale() {
  t_scale_ = 0;
}
inline float scaleTrans::t_scale() const {
  // @@protoc_insertion_point(field_get:pb.scaleTrans.t_scale)
  return t_scale_;
}
inline void scaleTrans::set_t_scale(float value) {
  
  t_scale_ = value;
  // @@protoc_insertion_point(field_set:pb.scaleTrans.t_scale)
}

// float r_scale = 3;
inline void scaleTrans::clear_r_scale() {
  r_scale_ = 0;
}
inline float scaleTrans::r_scale() const {
  // @@protoc_insertion_point(field_get:pb.scaleTrans.r_scale)
  return r_scale_;
}
inline void scaleTrans::set_r_scale(float value) {
  
  r_scale_ = value;
  // @@protoc_insertion_point(field_set:pb.scaleTrans.r_scale)
}

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

// flinTrans

// float min = 1;
inline void flinTrans::clear_min() {
  min_ = 0;
}
inline float flinTrans::min() const {
  // @@protoc_insertion_point(field_get:pb.flinTrans.min)
  return min_;
}
inline void flinTrans::set_min(float value) {
  
  min_ = value;
  // @@protoc_insertion_point(field_set:pb.flinTrans.min)
}

// float max = 2;
inline void flinTrans::clear_max() {
  max_ = 0;
}
inline float flinTrans::max() const {
  // @@protoc_insertion_point(field_get:pb.flinTrans.max)
  return max_;
}
inline void flinTrans::set_max(float value) {
  
  max_ = value;
  // @@protoc_insertion_point(field_set:pb.flinTrans.max)
}

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

// logTrans

// float offset = 1;
inline void logTrans::clear_offset() {
  offset_ = 0;
}
inline float logTrans::offset() const {
  // @@protoc_insertion_point(field_get:pb.logTrans.offset)
  return offset_;
}
inline void logTrans::set_offset(float value) {
  
  offset_ = value;
  // @@protoc_insertion_point(field_set:pb.logTrans.offset)
}

// float decade = 2;
inline void logTrans::clear_decade() {
  decade_ = 0;
}
inline float logTrans::decade() const {
  // @@protoc_insertion_point(field_get:pb.logTrans.decade)
  return decade_;
}
inline void logTrans::set_decade(float value) {
  
  decade_ = value;
  // @@protoc_insertion_point(field_set:pb.logTrans.decade)
}

// float T = 3;
inline void logTrans::clear_t() {
  t_ = 0;
}
inline float logTrans::t() const {
  // @@protoc_insertion_point(field_get:pb.logTrans.T)
  return t_;
}
inline void logTrans::set_t(float value) {
  
  t_ = value;
  // @@protoc_insertion_point(field_set:pb.logTrans.T)
}

// float scale = 4;
inline void logTrans::clear_scale() {
  scale_ = 0;
}
inline float logTrans::scale() const {
  // @@protoc_insertion_point(field_get:pb.logTrans.scale)
  return scale_;
}
inline void logTrans::set_scale(float value) {
  
  scale_ = value;
  // @@protoc_insertion_point(field_set:pb.logTrans.scale)
}

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

// logGML2Trans

// float T = 1;
inline void logGML2Trans::clear_t() {
  t_ = 0;
}
inline float logGML2Trans::t() const {
  // @@protoc_insertion_point(field_get:pb.logGML2Trans.T)
  return t_;
}
inline void logGML2Trans::set_t(float value) {
  
  t_ = value;
  // @@protoc_insertion_point(field_set:pb.logGML2Trans.T)
}

// float M = 2;
inline void logGML2Trans::clear_m() {
  m_ = 0;
}
inline float logGML2Trans::m() const {
  // @@protoc_insertion_point(field_get:pb.logGML2Trans.M)
  return m_;
}
inline void logGML2Trans::set_m(float value) {
  
  m_ = value;
  // @@protoc_insertion_point(field_set:pb.logGML2Trans.M)
}

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

// logicleTrans

// float T = 1;
inline void logicleTrans::clear_t() {
  t_ = 0;
}
inline float logicleTrans::t() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.T)
  return t_;
}
inline void logicleTrans::set_t(float value) {
  
  t_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.T)
}

// float W = 2;
inline void logicleTrans::clear_w() {
  w_ = 0;
}
inline float logicleTrans::w() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.W)
  return w_;
}
inline void logicleTrans::set_w(float value) {
  
  w_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.W)
}

// float M = 3;
inline void logicleTrans::clear_m() {
  m_ = 0;
}
inline float logicleTrans::m() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.M)
  return m_;
}
inline void logicleTrans::set_m(float value) {
  
  m_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.M)
}

// float A = 4;
inline void logicleTrans::clear_a() {
  a_ = 0;
}
inline float logicleTrans::a() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.A)
  return a_;
}
inline void logicleTrans::set_a(float value) {
  
  a_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.A)
}

// float bins = 5;
inline void logicleTrans::clear_bins() {
  bins_ = 0;
}
inline float logicleTrans::bins() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.bins)
  return bins_;
}
inline void logicleTrans::set_bins(float value) {
  
  bins_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.bins)
}

// bool isGml2 = 6;
inline void logicleTrans::clear_isgml2() {
  isgml2_ = false;
}
inline bool logicleTrans::isgml2() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.isGml2)
  return isgml2_;
}
inline void logicleTrans::set_isgml2(bool value) {
  
  isgml2_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.isGml2)
}

// bool isInverse = 7;
inline void logicleTrans::clear_isinverse() {
  isinverse_ = false;
}
inline bool logicleTrans::isinverse() const {
  // @@protoc_insertion_point(field_get:pb.logicleTrans.isInverse)
  return isinverse_;
}
inline void logicleTrans::set_isinverse(bool value) {
  
  isinverse_ = value;
  // @@protoc_insertion_point(field_set:pb.logicleTrans.isInverse)
}

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

// transformation

// .pb.calibrationTable calTbl = 1;
inline bool transformation::has_caltbl() const {
  return this != internal_default_instance() && caltbl_ != nullptr;
}
inline void transformation::clear_caltbl() {
  if (GetArenaNoVirtual() == nullptr && caltbl_ != nullptr) {
    delete caltbl_;
  }
  caltbl_ = nullptr;
}
inline const ::pb::calibrationTable& transformation::caltbl() const {
  const ::pb::calibrationTable* p = caltbl_;
  // @@protoc_insertion_point(field_get:pb.transformation.calTbl)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::calibrationTable*>(
      &::pb::_calibrationTable_default_instance_);
}
inline ::pb::calibrationTable* transformation::release_caltbl() {
  // @@protoc_insertion_point(field_release:pb.transformation.calTbl)
  
  ::pb::calibrationTable* temp = caltbl_;
  caltbl_ = nullptr;
  return temp;
}
inline ::pb::calibrationTable* transformation::mutable_caltbl() {
  
  if (caltbl_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::calibrationTable>(GetArenaNoVirtual());
    caltbl_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.calTbl)
  return caltbl_;
}
inline void transformation::set_allocated_caltbl(::pb::calibrationTable* caltbl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete caltbl_;
  }
  if (caltbl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      caltbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, caltbl, submessage_arena);
    }
    
  } else {
    
  }
  caltbl_ = caltbl;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.calTbl)
}

// bool isGateOnly = 2;
inline void transformation::clear_isgateonly() {
  isgateonly_ = false;
}
inline bool transformation::isgateonly() const {
  // @@protoc_insertion_point(field_get:pb.transformation.isGateOnly)
  return isgateonly_;
}
inline void transformation::set_isgateonly(bool value) {
  
  isgateonly_ = value;
  // @@protoc_insertion_point(field_set:pb.transformation.isGateOnly)
}

// string name = 4;
inline void transformation::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& transformation::name() const {
  // @@protoc_insertion_point(field_get:pb.transformation.name)
  return name_.GetNoArena();
}
inline void transformation::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.transformation.name)
}
inline void transformation::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.transformation.name)
}
inline void transformation::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.transformation.name)
}
inline void transformation::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.transformation.name)
}
inline std::string* transformation::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:pb.transformation.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* transformation::release_name() {
  // @@protoc_insertion_point(field_release:pb.transformation.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void transformation::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.name)
}

// string channel = 5;
inline void transformation::clear_channel() {
  channel_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& transformation::channel() const {
  // @@protoc_insertion_point(field_get:pb.transformation.channel)
  return channel_.GetNoArena();
}
inline void transformation::set_channel(const std::string& value) {
  
  channel_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.transformation.channel)
}
inline void transformation::set_channel(std::string&& value) {
  
  channel_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.transformation.channel)
}
inline void transformation::set_channel(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  channel_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.transformation.channel)
}
inline void transformation::set_channel(const char* value, size_t size) {
  
  channel_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.transformation.channel)
}
inline std::string* transformation::mutable_channel() {
  
  // @@protoc_insertion_point(field_mutable:pb.transformation.channel)
  return channel_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* transformation::release_channel() {
  // @@protoc_insertion_point(field_release:pb.transformation.channel)
  
  return channel_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void transformation::set_allocated_channel(std::string* channel) {
  if (channel != nullptr) {
    
  } else {
    
  }
  channel_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), channel);
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.channel)
}

// bool isComputed = 6;
inline void transformation::clear_iscomputed() {
  iscomputed_ = false;
}
inline bool transformation::iscomputed() const {
  // @@protoc_insertion_point(field_get:pb.transformation.isComputed)
  return iscomputed_;
}
inline void transformation::set_iscomputed(bool value) {
  
  iscomputed_ = value;
  // @@protoc_insertion_point(field_set:pb.transformation.isComputed)
}

// uint32 type = 12;
inline void transformation::clear_type() {
  type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 transformation::type() const {
  // @@protoc_insertion_point(field_get:pb.transformation.type)
  return type_;
}
inline void transformation::set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:pb.transformation.type)
}

// .pb.TRANS_TYPE trans_type = 3;
inline void transformation::clear_trans_type() {
  trans_type_ = 0;
}
inline ::pb::TRANS_TYPE transformation::trans_type() const {
  // @@protoc_insertion_point(field_get:pb.transformation.trans_type)
  return static_cast< ::pb::TRANS_TYPE >(trans_type_);
}
inline void transformation::set_trans_type(::pb::TRANS_TYPE value) {
  
  trans_type_ = value;
  // @@protoc_insertion_point(field_set:pb.transformation.trans_type)
}

// .pb.biexpTrans bt = 7;
inline bool transformation::has_bt() const {
  return this != internal_default_instance() && bt_ != nullptr;
}
inline void transformation::clear_bt() {
  if (GetArenaNoVirtual() == nullptr && bt_ != nullptr) {
    delete bt_;
  }
  bt_ = nullptr;
}
inline const ::pb::biexpTrans& transformation::bt() const {
  const ::pb::biexpTrans* p = bt_;
  // @@protoc_insertion_point(field_get:pb.transformation.bt)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::biexpTrans*>(
      &::pb::_biexpTrans_default_instance_);
}
inline ::pb::biexpTrans* transformation::release_bt() {
  // @@protoc_insertion_point(field_release:pb.transformation.bt)
  
  ::pb::biexpTrans* temp = bt_;
  bt_ = nullptr;
  return temp;
}
inline ::pb::biexpTrans* transformation::mutable_bt() {
  
  if (bt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::biexpTrans>(GetArenaNoVirtual());
    bt_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.bt)
  return bt_;
}
inline void transformation::set_allocated_bt(::pb::biexpTrans* bt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete bt_;
  }
  if (bt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      bt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bt, submessage_arena);
    }
    
  } else {
    
  }
  bt_ = bt;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.bt)
}

// .pb.logTrans lt = 8;
inline bool transformation::has_lt() const {
  return this != internal_default_instance() && lt_ != nullptr;
}
inline void transformation::clear_lt() {
  if (GetArenaNoVirtual() == nullptr && lt_ != nullptr) {
    delete lt_;
  }
  lt_ = nullptr;
}
inline const ::pb::logTrans& transformation::lt() const {
  const ::pb::logTrans* p = lt_;
  // @@protoc_insertion_point(field_get:pb.transformation.lt)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::logTrans*>(
      &::pb::_logTrans_default_instance_);
}
inline ::pb::logTrans* transformation::release_lt() {
  // @@protoc_insertion_point(field_release:pb.transformation.lt)
  
  ::pb::logTrans* temp = lt_;
  lt_ = nullptr;
  return temp;
}
inline ::pb::logTrans* transformation::mutable_lt() {
  
  if (lt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::logTrans>(GetArenaNoVirtual());
    lt_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.lt)
  return lt_;
}
inline void transformation::set_allocated_lt(::pb::logTrans* lt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete lt_;
  }
  if (lt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      lt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lt, submessage_arena);
    }
    
  } else {
    
  }
  lt_ = lt;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.lt)
}

// .pb.flinTrans flt = 9;
inline bool transformation::has_flt() const {
  return this != internal_default_instance() && flt_ != nullptr;
}
inline void transformation::clear_flt() {
  if (GetArenaNoVirtual() == nullptr && flt_ != nullptr) {
    delete flt_;
  }
  flt_ = nullptr;
}
inline const ::pb::flinTrans& transformation::flt() const {
  const ::pb::flinTrans* p = flt_;
  // @@protoc_insertion_point(field_get:pb.transformation.flt)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::flinTrans*>(
      &::pb::_flinTrans_default_instance_);
}
inline ::pb::flinTrans* transformation::release_flt() {
  // @@protoc_insertion_point(field_release:pb.transformation.flt)
  
  ::pb::flinTrans* temp = flt_;
  flt_ = nullptr;
  return temp;
}
inline ::pb::flinTrans* transformation::mutable_flt() {
  
  if (flt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::flinTrans>(GetArenaNoVirtual());
    flt_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.flt)
  return flt_;
}
inline void transformation::set_allocated_flt(::pb::flinTrans* flt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete flt_;
  }
  if (flt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      flt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flt, submessage_arena);
    }
    
  } else {
    
  }
  flt_ = flt;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.flt)
}

// .pb.scaleTrans st = 10;
inline bool transformation::has_st() const {
  return this != internal_default_instance() && st_ != nullptr;
}
inline void transformation::clear_st() {
  if (GetArenaNoVirtual() == nullptr && st_ != nullptr) {
    delete st_;
  }
  st_ = nullptr;
}
inline const ::pb::scaleTrans& transformation::st() const {
  const ::pb::scaleTrans* p = st_;
  // @@protoc_insertion_point(field_get:pb.transformation.st)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::scaleTrans*>(
      &::pb::_scaleTrans_default_instance_);
}
inline ::pb::scaleTrans* transformation::release_st() {
  // @@protoc_insertion_point(field_release:pb.transformation.st)
  
  ::pb::scaleTrans* temp = st_;
  st_ = nullptr;
  return temp;
}
inline ::pb::scaleTrans* transformation::mutable_st() {
  
  if (st_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::scaleTrans>(GetArenaNoVirtual());
    st_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.st)
  return st_;
}
inline void transformation::set_allocated_st(::pb::scaleTrans* st) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete st_;
  }
  if (st) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      st = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, st, submessage_arena);
    }
    
  } else {
    
  }
  st_ = st;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.st)
}

// .pb.fasinhTrans ft = 11;
inline bool transformation::has_ft() const {
  return this != internal_default_instance() && ft_ != nullptr;
}
inline void transformation::clear_ft() {
  if (GetArenaNoVirtual() == nullptr && ft_ != nullptr) {
    delete ft_;
  }
  ft_ = nullptr;
}
inline const ::pb::fasinhTrans& transformation::ft() const {
  const ::pb::fasinhTrans* p = ft_;
  // @@protoc_insertion_point(field_get:pb.transformation.ft)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::fasinhTrans*>(
      &::pb::_fasinhTrans_default_instance_);
}
inline ::pb::fasinhTrans* transformation::release_ft() {
  // @@protoc_insertion_point(field_release:pb.transformation.ft)
  
  ::pb::fasinhTrans* temp = ft_;
  ft_ = nullptr;
  return temp;
}
inline ::pb::fasinhTrans* transformation::mutable_ft() {
  
  if (ft_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::fasinhTrans>(GetArenaNoVirtual());
    ft_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.ft)
  return ft_;
}
inline void transformation::set_allocated_ft(::pb::fasinhTrans* ft) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete ft_;
  }
  if (ft) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      ft = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ft, submessage_arena);
    }
    
  } else {
    
  }
  ft_ = ft;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.ft)
}

// .pb.logicleTrans lgt = 13;
inline bool transformation::has_lgt() const {
  return this != internal_default_instance() && lgt_ != nullptr;
}
inline void transformation::clear_lgt() {
  if (GetArenaNoVirtual() == nullptr && lgt_ != nullptr) {
    delete lgt_;
  }
  lgt_ = nullptr;
}
inline const ::pb::logicleTrans& transformation::lgt() const {
  const ::pb::logicleTrans* p = lgt_;
  // @@protoc_insertion_point(field_get:pb.transformation.lgt)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::logicleTrans*>(
      &::pb::_logicleTrans_default_instance_);
}
inline ::pb::logicleTrans* transformation::release_lgt() {
  // @@protoc_insertion_point(field_release:pb.transformation.lgt)
  
  ::pb::logicleTrans* temp = lgt_;
  lgt_ = nullptr;
  return temp;
}
inline ::pb::logicleTrans* transformation::mutable_lgt() {
  
  if (lgt_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::logicleTrans>(GetArenaNoVirtual());
    lgt_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.lgt)
  return lgt_;
}
inline void transformation::set_allocated_lgt(::pb::logicleTrans* lgt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete lgt_;
  }
  if (lgt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      lgt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lgt, submessage_arena);
    }
    
  } else {
    
  }
  lgt_ = lgt;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.lgt)
}

// .pb.logGML2Trans lgml2t = 14;
inline bool transformation::has_lgml2t() const {
  return this != internal_default_instance() && lgml2t_ != nullptr;
}
inline void transformation::clear_lgml2t() {
  if (GetArenaNoVirtual() == nullptr && lgml2t_ != nullptr) {
    delete lgml2t_;
  }
  lgml2t_ = nullptr;
}
inline const ::pb::logGML2Trans& transformation::lgml2t() const {
  const ::pb::logGML2Trans* p = lgml2t_;
  // @@protoc_insertion_point(field_get:pb.transformation.lgml2t)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::logGML2Trans*>(
      &::pb::_logGML2Trans_default_instance_);
}
inline ::pb::logGML2Trans* transformation::release_lgml2t() {
  // @@protoc_insertion_point(field_release:pb.transformation.lgml2t)
  
  ::pb::logGML2Trans* temp = lgml2t_;
  lgml2t_ = nullptr;
  return temp;
}
inline ::pb::logGML2Trans* transformation::mutable_lgml2t() {
  
  if (lgml2t_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::logGML2Trans>(GetArenaNoVirtual());
    lgml2t_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.transformation.lgml2t)
  return lgml2t_;
}
inline void transformation::set_allocated_lgml2t(::pb::logGML2Trans* lgml2t) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete lgml2t_;
  }
  if (lgml2t) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      lgml2t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lgml2t, submessage_arena);
    }
    
  } else {
    
  }
  lgml2t_ = lgml2t;
  // @@protoc_insertion_point(field_set_allocated:pb.transformation.lgml2t)
}

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

// trans_pair

// string name = 1;
inline void trans_pair::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& trans_pair::name() const {
  // @@protoc_insertion_point(field_get:pb.trans_pair.name)
  return name_.GetNoArena();
}
inline void trans_pair::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.trans_pair.name)
}
inline void trans_pair::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.trans_pair.name)
}
inline void trans_pair::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.trans_pair.name)
}
inline void trans_pair::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.trans_pair.name)
}
inline std::string* trans_pair::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:pb.trans_pair.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* trans_pair::release_name() {
  // @@protoc_insertion_point(field_release:pb.trans_pair.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void trans_pair::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:pb.trans_pair.name)
}

// uint64 trans_address = 2;
inline void trans_pair::clear_trans_address() {
  trans_address_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 trans_pair::trans_address() const {
  // @@protoc_insertion_point(field_get:pb.trans_pair.trans_address)
  return trans_address_;
}
inline void trans_pair::set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  trans_address_ = value;
  // @@protoc_insertion_point(field_set:pb.trans_pair.trans_address)
}

// .pb.transformation trans = 3;
inline bool trans_pair::has_trans() const {
  return this != internal_default_instance() && trans_ != nullptr;
}
inline void trans_pair::clear_trans() {
  if (GetArenaNoVirtual() == nullptr && trans_ != nullptr) {
    delete trans_;
  }
  trans_ = nullptr;
}
inline const ::pb::transformation& trans_pair::trans() const {
  const ::pb::transformation* p = trans_;
  // @@protoc_insertion_point(field_get:pb.trans_pair.trans)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::transformation*>(
      &::pb::_transformation_default_instance_);
}
inline ::pb::transformation* trans_pair::release_trans() {
  // @@protoc_insertion_point(field_release:pb.trans_pair.trans)
  
  ::pb::transformation* temp = trans_;
  trans_ = nullptr;
  return temp;
}
inline ::pb::transformation* trans_pair::mutable_trans() {
  
  if (trans_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::transformation>(GetArenaNoVirtual());
    trans_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.trans_pair.trans)
  return trans_;
}
inline void trans_pair::set_allocated_trans(::pb::transformation* trans) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete trans_;
  }
  if (trans) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      trans = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trans, submessage_arena);
    }
    
  } else {
    
  }
  trans_ = trans;
  // @@protoc_insertion_point(field_set_allocated:pb.trans_pair.trans)
}

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

// trans_local

// repeated .pb.trans_pair tp = 1;
inline int trans_local::tp_size() const {
  return tp_.size();
}
inline void trans_local::clear_tp() {
  tp_.Clear();
}
inline ::pb::trans_pair* trans_local::mutable_tp(int index) {
  // @@protoc_insertion_point(field_mutable:pb.trans_local.tp)
  return tp_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >*
trans_local::mutable_tp() {
  // @@protoc_insertion_point(field_mutable_list:pb.trans_local.tp)
  return &tp_;
}
inline const ::pb::trans_pair& trans_local::tp(int index) const {
  // @@protoc_insertion_point(field_get:pb.trans_local.tp)
  return tp_.Get(index);
}
inline ::pb::trans_pair* trans_local::add_tp() {
  // @@protoc_insertion_point(field_add:pb.trans_local.tp)
  return tp_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >&
trans_local::tp() const {
  // @@protoc_insertion_point(field_list:pb.trans_local.tp)
  return tp_;
}

// string groupName = 2;
inline void trans_local::clear_groupname() {
  groupname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& trans_local::groupname() const {
  // @@protoc_insertion_point(field_get:pb.trans_local.groupName)
  return groupname_.GetNoArena();
}
inline void trans_local::set_groupname(const std::string& value) {
  
  groupname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.trans_local.groupName)
}
inline void trans_local::set_groupname(std::string&& value) {
  
  groupname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.trans_local.groupName)
}
inline void trans_local::set_groupname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  groupname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.trans_local.groupName)
}
inline void trans_local::set_groupname(const char* value, size_t size) {
  
  groupname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.trans_local.groupName)
}
inline std::string* trans_local::mutable_groupname() {
  
  // @@protoc_insertion_point(field_mutable:pb.trans_local.groupName)
  return groupname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* trans_local::release_groupname() {
  // @@protoc_insertion_point(field_release:pb.trans_local.groupName)
  
  return groupname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void trans_local::set_allocated_groupname(std::string* groupname) {
  if (groupname != nullptr) {
    
  } else {
    
  }
  groupname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), groupname);
  // @@protoc_insertion_point(field_set_allocated:pb.trans_local.groupName)
}

// repeated uint32 sampleIDs = 3 [packed = true];
inline int trans_local::sampleids_size() const {
  return sampleids_.size();
}
inline void trans_local::clear_sampleids() {
  sampleids_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 trans_local::sampleids(int index) const {
  // @@protoc_insertion_point(field_get:pb.trans_local.sampleIDs)
  return sampleids_.Get(index);
}
inline void trans_local::set_sampleids(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) {
  sampleids_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.trans_local.sampleIDs)
}
inline void trans_local::add_sampleids(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  sampleids_.Add(value);
  // @@protoc_insertion_point(field_add:pb.trans_local.sampleIDs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
trans_local::sampleids() const {
  // @@protoc_insertion_point(field_list:pb.trans_local.sampleIDs)
  return sampleids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
trans_local::mutable_sampleids() {
  // @@protoc_insertion_point(field_mutable_list:pb.trans_local.sampleIDs)
  return &sampleids_;
}

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

// POPINDICES

// uint32 nEvents = 1;
inline void POPINDICES::clear_nevents() {
  nevents_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 POPINDICES::nevents() const {
  // @@protoc_insertion_point(field_get:pb.POPINDICES.nEvents)
  return nevents_;
}
inline void POPINDICES::set_nevents(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  nevents_ = value;
  // @@protoc_insertion_point(field_set:pb.POPINDICES.nEvents)
}

// .pb.ind_type indtype = 2;
inline void POPINDICES::clear_indtype() {
  indtype_ = 0;
}
inline ::pb::ind_type POPINDICES::indtype() const {
  // @@protoc_insertion_point(field_get:pb.POPINDICES.indtype)
  return static_cast< ::pb::ind_type >(indtype_);
}
inline void POPINDICES::set_indtype(::pb::ind_type value) {
  
  indtype_ = value;
  // @@protoc_insertion_point(field_set:pb.POPINDICES.indtype)
}

// repeated uint32 iInd = 3 [packed = true];
inline int POPINDICES::iind_size() const {
  return iind_.size();
}
inline void POPINDICES::clear_iind() {
  iind_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 POPINDICES::iind(int index) const {
  // @@protoc_insertion_point(field_get:pb.POPINDICES.iInd)
  return iind_.Get(index);
}
inline void POPINDICES::set_iind(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) {
  iind_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.POPINDICES.iInd)
}
inline void POPINDICES::add_iind(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  iind_.Add(value);
  // @@protoc_insertion_point(field_add:pb.POPINDICES.iInd)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
POPINDICES::iind() const {
  // @@protoc_insertion_point(field_list:pb.POPINDICES.iInd)
  return iind_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
POPINDICES::mutable_iind() {
  // @@protoc_insertion_point(field_mutable_list:pb.POPINDICES.iInd)
  return &iind_;
}

// bytes bInd = 4;
inline void POPINDICES::clear_bind() {
  bind_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& POPINDICES::bind() const {
  // @@protoc_insertion_point(field_get:pb.POPINDICES.bInd)
  return bind_.GetNoArena();
}
inline void POPINDICES::set_bind(const std::string& value) {
  
  bind_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.POPINDICES.bInd)
}
inline void POPINDICES::set_bind(std::string&& value) {
  
  bind_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.POPINDICES.bInd)
}
inline void POPINDICES::set_bind(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  bind_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.POPINDICES.bInd)
}
inline void POPINDICES::set_bind(const void* value, size_t size) {
  
  bind_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.POPINDICES.bInd)
}
inline std::string* POPINDICES::mutable_bind() {
  
  // @@protoc_insertion_point(field_mutable:pb.POPINDICES.bInd)
  return bind_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* POPINDICES::release_bind() {
  // @@protoc_insertion_point(field_release:pb.POPINDICES.bInd)
  
  return bind_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void POPINDICES::set_allocated_bind(std::string* bind) {
  if (bind != nullptr) {
    
  } else {
    
  }
  bind_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bind);
  // @@protoc_insertion_point(field_set_allocated:pb.POPINDICES.bInd)
}

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

// nodeProperties

// string thisName = 1;
inline void nodeProperties::clear_thisname() {
  thisname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& nodeProperties::thisname() const {
  // @@protoc_insertion_point(field_get:pb.nodeProperties.thisName)
  return thisname_.GetNoArena();
}
inline void nodeProperties::set_thisname(const std::string& value) {
  
  thisname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.nodeProperties.thisName)
}
inline void nodeProperties::set_thisname(std::string&& value) {
  
  thisname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.nodeProperties.thisName)
}
inline void nodeProperties::set_thisname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  thisname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.nodeProperties.thisName)
}
inline void nodeProperties::set_thisname(const char* value, size_t size) {
  
  thisname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.nodeProperties.thisName)
}
inline std::string* nodeProperties::mutable_thisname() {
  
  // @@protoc_insertion_point(field_mutable:pb.nodeProperties.thisName)
  return thisname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* nodeProperties::release_thisname() {
  // @@protoc_insertion_point(field_release:pb.nodeProperties.thisName)
  
  return thisname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void nodeProperties::set_allocated_thisname(std::string* thisname) {
  if (thisname != nullptr) {
    
  } else {
    
  }
  thisname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), thisname);
  // @@protoc_insertion_point(field_set_allocated:pb.nodeProperties.thisName)
}

// repeated .pb.POPSTATS fjStats = 2;
inline int nodeProperties::fjstats_size() const {
  return fjstats_.size();
}
inline void nodeProperties::clear_fjstats() {
  fjstats_.Clear();
}
inline ::pb::POPSTATS* nodeProperties::mutable_fjstats(int index) {
  // @@protoc_insertion_point(field_mutable:pb.nodeProperties.fjStats)
  return fjstats_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >*
nodeProperties::mutable_fjstats() {
  // @@protoc_insertion_point(field_mutable_list:pb.nodeProperties.fjStats)
  return &fjstats_;
}
inline const ::pb::POPSTATS& nodeProperties::fjstats(int index) const {
  // @@protoc_insertion_point(field_get:pb.nodeProperties.fjStats)
  return fjstats_.Get(index);
}
inline ::pb::POPSTATS* nodeProperties::add_fjstats() {
  // @@protoc_insertion_point(field_add:pb.nodeProperties.fjStats)
  return fjstats_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >&
nodeProperties::fjstats() const {
  // @@protoc_insertion_point(field_list:pb.nodeProperties.fjStats)
  return fjstats_;
}

// repeated .pb.POPSTATS fcStats = 3;
inline int nodeProperties::fcstats_size() const {
  return fcstats_.size();
}
inline void nodeProperties::clear_fcstats() {
  fcstats_.Clear();
}
inline ::pb::POPSTATS* nodeProperties::mutable_fcstats(int index) {
  // @@protoc_insertion_point(field_mutable:pb.nodeProperties.fcStats)
  return fcstats_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >*
nodeProperties::mutable_fcstats() {
  // @@protoc_insertion_point(field_mutable_list:pb.nodeProperties.fcStats)
  return &fcstats_;
}
inline const ::pb::POPSTATS& nodeProperties::fcstats(int index) const {
  // @@protoc_insertion_point(field_get:pb.nodeProperties.fcStats)
  return fcstats_.Get(index);
}
inline ::pb::POPSTATS* nodeProperties::add_fcstats() {
  // @@protoc_insertion_point(field_add:pb.nodeProperties.fcStats)
  return fcstats_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >&
nodeProperties::fcstats() const {
  // @@protoc_insertion_point(field_list:pb.nodeProperties.fcStats)
  return fcstats_;
}

// bool hidden = 4;
inline void nodeProperties::clear_hidden() {
  hidden_ = false;
}
inline bool nodeProperties::hidden() const {
  // @@protoc_insertion_point(field_get:pb.nodeProperties.hidden)
  return hidden_;
}
inline void nodeProperties::set_hidden(bool value) {
  
  hidden_ = value;
  // @@protoc_insertion_point(field_set:pb.nodeProperties.hidden)
}

// .pb.POPINDICES indices = 5;
inline bool nodeProperties::has_indices() const {
  return this != internal_default_instance() && indices_ != nullptr;
}
inline void nodeProperties::clear_indices() {
  if (GetArenaNoVirtual() == nullptr && indices_ != nullptr) {
    delete indices_;
  }
  indices_ = nullptr;
}
inline const ::pb::POPINDICES& nodeProperties::indices() const {
  const ::pb::POPINDICES* p = indices_;
  // @@protoc_insertion_point(field_get:pb.nodeProperties.indices)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::POPINDICES*>(
      &::pb::_POPINDICES_default_instance_);
}
inline ::pb::POPINDICES* nodeProperties::release_indices() {
  // @@protoc_insertion_point(field_release:pb.nodeProperties.indices)
  
  ::pb::POPINDICES* temp = indices_;
  indices_ = nullptr;
  return temp;
}
inline ::pb::POPINDICES* nodeProperties::mutable_indices() {
  
  if (indices_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::POPINDICES>(GetArenaNoVirtual());
    indices_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.nodeProperties.indices)
  return indices_;
}
inline void nodeProperties::set_allocated_indices(::pb::POPINDICES* indices) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete indices_;
  }
  if (indices) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, indices, submessage_arena);
    }
    
  } else {
    
  }
  indices_ = indices;
  // @@protoc_insertion_point(field_set_allocated:pb.nodeProperties.indices)
}

// .pb.gate thisGate = 6;
inline bool nodeProperties::has_thisgate() const {
  return this != internal_default_instance() && thisgate_ != nullptr;
}
inline void nodeProperties::clear_thisgate() {
  if (GetArenaNoVirtual() == nullptr && thisgate_ != nullptr) {
    delete thisgate_;
  }
  thisgate_ = nullptr;
}
inline const ::pb::gate& nodeProperties::thisgate() const {
  const ::pb::gate* p = thisgate_;
  // @@protoc_insertion_point(field_get:pb.nodeProperties.thisGate)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::gate*>(
      &::pb::_gate_default_instance_);
}
inline ::pb::gate* nodeProperties::release_thisgate() {
  // @@protoc_insertion_point(field_release:pb.nodeProperties.thisGate)
  
  ::pb::gate* temp = thisgate_;
  thisgate_ = nullptr;
  return temp;
}
inline ::pb::gate* nodeProperties::mutable_thisgate() {
  
  if (thisgate_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::gate>(GetArenaNoVirtual());
    thisgate_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.nodeProperties.thisGate)
  return thisgate_;
}
inline void nodeProperties::set_allocated_thisgate(::pb::gate* thisgate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete thisgate_;
  }
  if (thisgate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      thisgate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, thisgate, submessage_arena);
    }
    
  } else {
    
  }
  thisgate_ = thisgate;
  // @@protoc_insertion_point(field_set_allocated:pb.nodeProperties.thisGate)
}

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

// treeNodes

// .pb.nodeProperties node = 1;
inline bool treeNodes::has_node() const {
  return this != internal_default_instance() && node_ != nullptr;
}
inline void treeNodes::clear_node() {
  if (GetArenaNoVirtual() == nullptr && node_ != nullptr) {
    delete node_;
  }
  node_ = nullptr;
}
inline const ::pb::nodeProperties& treeNodes::node() const {
  const ::pb::nodeProperties* p = node_;
  // @@protoc_insertion_point(field_get:pb.treeNodes.node)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::nodeProperties*>(
      &::pb::_nodeProperties_default_instance_);
}
inline ::pb::nodeProperties* treeNodes::release_node() {
  // @@protoc_insertion_point(field_release:pb.treeNodes.node)
  
  ::pb::nodeProperties* temp = node_;
  node_ = nullptr;
  return temp;
}
inline ::pb::nodeProperties* treeNodes::mutable_node() {
  
  if (node_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::nodeProperties>(GetArenaNoVirtual());
    node_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.treeNodes.node)
  return node_;
}
inline void treeNodes::set_allocated_node(::pb::nodeProperties* node) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete node_;
  }
  if (node) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    
  } else {
    
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:pb.treeNodes.node)
}

// uint32 parent = 2;
inline void treeNodes::clear_parent() {
  parent_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 treeNodes::parent() const {
  // @@protoc_insertion_point(field_get:pb.treeNodes.parent)
  return parent_;
}
inline void treeNodes::set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  parent_ = value;
  // @@protoc_insertion_point(field_set:pb.treeNodes.parent)
}

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

// populationTree

// repeated .pb.treeNodes node = 1;
inline int populationTree::node_size() const {
  return node_.size();
}
inline void populationTree::clear_node() {
  node_.Clear();
}
inline ::pb::treeNodes* populationTree::mutable_node(int index) {
  // @@protoc_insertion_point(field_mutable:pb.populationTree.node)
  return node_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >*
populationTree::mutable_node() {
  // @@protoc_insertion_point(field_mutable_list:pb.populationTree.node)
  return &node_;
}
inline const ::pb::treeNodes& populationTree::node(int index) const {
  // @@protoc_insertion_point(field_get:pb.populationTree.node)
  return node_.Get(index);
}
inline ::pb::treeNodes* populationTree::add_node() {
  // @@protoc_insertion_point(field_add:pb.populationTree.node)
  return node_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >&
populationTree::node() const {
  // @@protoc_insertion_point(field_list:pb.populationTree.node)
  return node_;
}

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

// COMP

// string cid = 1;
inline void COMP::clear_cid() {
  cid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& COMP::cid() const {
  // @@protoc_insertion_point(field_get:pb.COMP.cid)
  return cid_.GetNoArena();
}
inline void COMP::set_cid(const std::string& value) {
  
  cid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.COMP.cid)
}
inline void COMP::set_cid(std::string&& value) {
  
  cid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.COMP.cid)
}
inline void COMP::set_cid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.COMP.cid)
}
inline void COMP::set_cid(const char* value, size_t size) {
  
  cid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.cid)
}
inline std::string* COMP::mutable_cid() {
  
  // @@protoc_insertion_point(field_mutable:pb.COMP.cid)
  return cid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* COMP::release_cid() {
  // @@protoc_insertion_point(field_release:pb.COMP.cid)
  
  return cid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void COMP::set_allocated_cid(std::string* cid) {
  if (cid != nullptr) {
    
  } else {
    
  }
  cid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cid);
  // @@protoc_insertion_point(field_set_allocated:pb.COMP.cid)
}

// string prefix = 2;
inline void COMP::clear_prefix() {
  prefix_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& COMP::prefix() const {
  // @@protoc_insertion_point(field_get:pb.COMP.prefix)
  return prefix_.GetNoArena();
}
inline void COMP::set_prefix(const std::string& value) {
  
  prefix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.COMP.prefix)
}
inline void COMP::set_prefix(std::string&& value) {
  
  prefix_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.COMP.prefix)
}
inline void COMP::set_prefix(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  prefix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.COMP.prefix)
}
inline void COMP::set_prefix(const char* value, size_t size) {
  
  prefix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.prefix)
}
inline std::string* COMP::mutable_prefix() {
  
  // @@protoc_insertion_point(field_mutable:pb.COMP.prefix)
  return prefix_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* COMP::release_prefix() {
  // @@protoc_insertion_point(field_release:pb.COMP.prefix)
  
  return prefix_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void COMP::set_allocated_prefix(std::string* prefix) {
  if (prefix != nullptr) {
    
  } else {
    
  }
  prefix_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), prefix);
  // @@protoc_insertion_point(field_set_allocated:pb.COMP.prefix)
}

// string suffix = 3;
inline void COMP::clear_suffix() {
  suffix_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& COMP::suffix() const {
  // @@protoc_insertion_point(field_get:pb.COMP.suffix)
  return suffix_.GetNoArena();
}
inline void COMP::set_suffix(const std::string& value) {
  
  suffix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.COMP.suffix)
}
inline void COMP::set_suffix(std::string&& value) {
  
  suffix_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.COMP.suffix)
}
inline void COMP::set_suffix(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  suffix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.COMP.suffix)
}
inline void COMP::set_suffix(const char* value, size_t size) {
  
  suffix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.suffix)
}
inline std::string* COMP::mutable_suffix() {
  
  // @@protoc_insertion_point(field_mutable:pb.COMP.suffix)
  return suffix_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* COMP::release_suffix() {
  // @@protoc_insertion_point(field_release:pb.COMP.suffix)
  
  return suffix_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void COMP::set_allocated_suffix(std::string* suffix) {
  if (suffix != nullptr) {
    
  } else {
    
  }
  suffix_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), suffix);
  // @@protoc_insertion_point(field_set_allocated:pb.COMP.suffix)
}

// string name = 4;
inline void COMP::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& COMP::name() const {
  // @@protoc_insertion_point(field_get:pb.COMP.name)
  return name_.GetNoArena();
}
inline void COMP::set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.COMP.name)
}
inline void COMP::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.COMP.name)
}
inline void COMP::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.COMP.name)
}
inline void COMP::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.name)
}
inline std::string* COMP::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:pb.COMP.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* COMP::release_name() {
  // @@protoc_insertion_point(field_release:pb.COMP.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void COMP::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:pb.COMP.name)
}

// string comment = 5;
inline void COMP::clear_comment() {
  comment_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& COMP::comment() const {
  // @@protoc_insertion_point(field_get:pb.COMP.comment)
  return comment_.GetNoArena();
}
inline void COMP::set_comment(const std::string& value) {
  
  comment_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.COMP.comment)
}
inline void COMP::set_comment(std::string&& value) {
  
  comment_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.COMP.comment)
}
inline void COMP::set_comment(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  comment_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.COMP.comment)
}
inline void COMP::set_comment(const char* value, size_t size) {
  
  comment_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.comment)
}
inline std::string* COMP::mutable_comment() {
  
  // @@protoc_insertion_point(field_mutable:pb.COMP.comment)
  return comment_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* COMP::release_comment() {
  // @@protoc_insertion_point(field_release:pb.COMP.comment)
  
  return comment_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void COMP::set_allocated_comment(std::string* comment) {
  if (comment != nullptr) {
    
  } else {
    
  }
  comment_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comment);
  // @@protoc_insertion_point(field_set_allocated:pb.COMP.comment)
}

// repeated string marker = 6;
inline int COMP::marker_size() const {
  return marker_.size();
}
inline void COMP::clear_marker() {
  marker_.Clear();
}
inline const std::string& COMP::marker(int index) const {
  // @@protoc_insertion_point(field_get:pb.COMP.marker)
  return marker_.Get(index);
}
inline std::string* COMP::mutable_marker(int index) {
  // @@protoc_insertion_point(field_mutable:pb.COMP.marker)
  return marker_.Mutable(index);
}
inline void COMP::set_marker(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.COMP.marker)
  marker_.Mutable(index)->assign(value);
}
inline void COMP::set_marker(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.COMP.marker)
  marker_.Mutable(index)->assign(std::move(value));
}
inline void COMP::set_marker(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  marker_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.COMP.marker)
}
inline void COMP::set_marker(int index, const char* value, size_t size) {
  marker_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.marker)
}
inline std::string* COMP::add_marker() {
  // @@protoc_insertion_point(field_add_mutable:pb.COMP.marker)
  return marker_.Add();
}
inline void COMP::add_marker(const std::string& value) {
  marker_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.COMP.marker)
}
inline void COMP::add_marker(std::string&& value) {
  marker_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.COMP.marker)
}
inline void COMP::add_marker(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  marker_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.COMP.marker)
}
inline void COMP::add_marker(const char* value, size_t size) {
  marker_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.COMP.marker)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
COMP::marker() const {
  // @@protoc_insertion_point(field_list:pb.COMP.marker)
  return marker_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
COMP::mutable_marker() {
  // @@protoc_insertion_point(field_mutable_list:pb.COMP.marker)
  return &marker_;
}

// repeated float spillOver = 7;
inline int COMP::spillover_size() const {
  return spillover_.size();
}
inline void COMP::clear_spillover() {
  spillover_.Clear();
}
inline float COMP::spillover(int index) const {
  // @@protoc_insertion_point(field_get:pb.COMP.spillOver)
  return spillover_.Get(index);
}
inline void COMP::set_spillover(int index, float value) {
  spillover_.Set(index, value);
  // @@protoc_insertion_point(field_set:pb.COMP.spillOver)
}
inline void COMP::add_spillover(float value) {
  spillover_.Add(value);
  // @@protoc_insertion_point(field_add:pb.COMP.spillOver)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
COMP::spillover() const {
  // @@protoc_insertion_point(field_list:pb.COMP.spillOver)
  return spillover_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
COMP::mutable_spillover() {
  // @@protoc_insertion_point(field_mutable_list:pb.COMP.spillOver)
  return &spillover_;
}

// repeated string detector = 8;
inline int COMP::detector_size() const {
  return detector_.size();
}
inline void COMP::clear_detector() {
  detector_.Clear();
}
inline const std::string& COMP::detector(int index) const {
  // @@protoc_insertion_point(field_get:pb.COMP.detector)
  return detector_.Get(index);
}
inline std::string* COMP::mutable_detector(int index) {
  // @@protoc_insertion_point(field_mutable:pb.COMP.detector)
  return detector_.Mutable(index);
}
inline void COMP::set_detector(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.COMP.detector)
  detector_.Mutable(index)->assign(value);
}
inline void COMP::set_detector(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.COMP.detector)
  detector_.Mutable(index)->assign(std::move(value));
}
inline void COMP::set_detector(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  detector_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.COMP.detector)
}
inline void COMP::set_detector(int index, const char* value, size_t size) {
  detector_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.COMP.detector)
}
inline std::string* COMP::add_detector() {
  // @@protoc_insertion_point(field_add_mutable:pb.COMP.detector)
  return detector_.Add();
}
inline void COMP::add_detector(const std::string& value) {
  detector_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.COMP.detector)
}
inline void COMP::add_detector(std::string&& value) {
  detector_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.COMP.detector)
}
inline void COMP::add_detector(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  detector_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.COMP.detector)
}
inline void COMP::add_detector(const char* value, size_t size) {
  detector_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.COMP.detector)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
COMP::detector() const {
  // @@protoc_insertion_point(field_list:pb.COMP.detector)
  return detector_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
COMP::mutable_detector() {
  // @@protoc_insertion_point(field_mutable_list:pb.COMP.detector)
  return &detector_;
}

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

// PARAM

// string param = 1;
inline void PARAM::clear_param() {
  param_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PARAM::param() const {
  // @@protoc_insertion_point(field_get:pb.PARAM.param)
  return param_.GetNoArena();
}
inline void PARAM::set_param(const std::string& value) {
  
  param_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.PARAM.param)
}
inline void PARAM::set_param(std::string&& value) {
  
  param_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.PARAM.param)
}
inline void PARAM::set_param(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  param_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.PARAM.param)
}
inline void PARAM::set_param(const char* value, size_t size) {
  
  param_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.PARAM.param)
}
inline std::string* PARAM::mutable_param() {
  
  // @@protoc_insertion_point(field_mutable:pb.PARAM.param)
  return param_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PARAM::release_param() {
  // @@protoc_insertion_point(field_release:pb.PARAM.param)
  
  return param_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PARAM::set_allocated_param(std::string* param) {
  if (param != nullptr) {
    
  } else {
    
  }
  param_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), param);
  // @@protoc_insertion_point(field_set_allocated:pb.PARAM.param)
}

// bool log = 2;
inline void PARAM::clear_log() {
  log_ = false;
}
inline bool PARAM::log() const {
  // @@protoc_insertion_point(field_get:pb.PARAM.log)
  return log_;
}
inline void PARAM::set_log(bool value) {
  
  log_ = value;
  // @@protoc_insertion_point(field_set:pb.PARAM.log)
}

// uint32 range = 3;
inline void PARAM::clear_range() {
  range_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::range() const {
  // @@protoc_insertion_point(field_get:pb.PARAM.range)
  return range_;
}
inline void PARAM::set_range(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  range_ = value;
  // @@protoc_insertion_point(field_set:pb.PARAM.range)
}

// uint32 highValue = 4;
inline void PARAM::clear_highvalue() {
  highvalue_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::highvalue() const {
  // @@protoc_insertion_point(field_get:pb.PARAM.highValue)
  return highvalue_;
}
inline void PARAM::set_highvalue(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  highvalue_ = value;
  // @@protoc_insertion_point(field_set:pb.PARAM.highValue)
}

// uint32 calibrationIndex = 5;
inline void PARAM::clear_calibrationindex() {
  calibrationindex_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::calibrationindex() const {
  // @@protoc_insertion_point(field_get:pb.PARAM.calibrationIndex)
  return calibrationindex_;
}
inline void PARAM::set_calibrationindex(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  calibrationindex_ = value;
  // @@protoc_insertion_point(field_set:pb.PARAM.calibrationIndex)
}

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

// GatingHierarchy

// .pb.populationTree tree = 2;
inline bool GatingHierarchy::has_tree() const {
  return this != internal_default_instance() && tree_ != nullptr;
}
inline void GatingHierarchy::clear_tree() {
  if (GetArenaNoVirtual() == nullptr && tree_ != nullptr) {
    delete tree_;
  }
  tree_ = nullptr;
}
inline const ::pb::populationTree& GatingHierarchy::tree() const {
  const ::pb::populationTree* p = tree_;
  // @@protoc_insertion_point(field_get:pb.GatingHierarchy.tree)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::populationTree*>(
      &::pb::_populationTree_default_instance_);
}
inline ::pb::populationTree* GatingHierarchy::release_tree() {
  // @@protoc_insertion_point(field_release:pb.GatingHierarchy.tree)
  
  ::pb::populationTree* temp = tree_;
  tree_ = nullptr;
  return temp;
}
inline ::pb::populationTree* GatingHierarchy::mutable_tree() {
  
  if (tree_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::populationTree>(GetArenaNoVirtual());
    tree_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.tree)
  return tree_;
}
inline void GatingHierarchy::set_allocated_tree(::pb::populationTree* tree) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete tree_;
  }
  if (tree) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      tree = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tree, submessage_arena);
    }
    
  } else {
    
  }
  tree_ = tree;
  // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.tree)
}

// .pb.COMP comp = 1;
inline bool GatingHierarchy::has_comp() const {
  return this != internal_default_instance() && comp_ != nullptr;
}
inline void GatingHierarchy::clear_comp() {
  if (GetArenaNoVirtual() == nullptr && comp_ != nullptr) {
    delete comp_;
  }
  comp_ = nullptr;
}
inline const ::pb::COMP& GatingHierarchy::comp() const {
  const ::pb::COMP* p = comp_;
  // @@protoc_insertion_point(field_get:pb.GatingHierarchy.comp)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::COMP*>(
      &::pb::_COMP_default_instance_);
}
inline ::pb::COMP* GatingHierarchy::release_comp() {
  // @@protoc_insertion_point(field_release:pb.GatingHierarchy.comp)
  
  ::pb::COMP* temp = comp_;
  comp_ = nullptr;
  return temp;
}
inline ::pb::COMP* GatingHierarchy::mutable_comp() {
  
  if (comp_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::COMP>(GetArenaNoVirtual());
    comp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.comp)
  return comp_;
}
inline void GatingHierarchy::set_allocated_comp(::pb::COMP* comp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete comp_;
  }
  if (comp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comp, submessage_arena);
    }
    
  } else {
    
  }
  comp_ = comp;
  // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.comp)
}

// bool isLoaded = 3;
inline void GatingHierarchy::clear_isloaded() {
  isloaded_ = false;
}
inline bool GatingHierarchy::isloaded() const {
  // @@protoc_insertion_point(field_get:pb.GatingHierarchy.isLoaded)
  return isloaded_;
}
inline void GatingHierarchy::set_isloaded(bool value) {
  
  isloaded_ = value;
  // @@protoc_insertion_point(field_set:pb.GatingHierarchy.isLoaded)
}

// repeated .pb.PARAM transFlag = 4;
inline int GatingHierarchy::transflag_size() const {
  return transflag_.size();
}
inline void GatingHierarchy::clear_transflag() {
  transflag_.Clear();
}
inline ::pb::PARAM* GatingHierarchy::mutable_transflag(int index) {
  // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.transFlag)
  return transflag_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >*
GatingHierarchy::mutable_transflag() {
  // @@protoc_insertion_point(field_mutable_list:pb.GatingHierarchy.transFlag)
  return &transflag_;
}
inline const ::pb::PARAM& GatingHierarchy::transflag(int index) const {
  // @@protoc_insertion_point(field_get:pb.GatingHierarchy.transFlag)
  return transflag_.Get(index);
}
inline ::pb::PARAM* GatingHierarchy::add_transflag() {
  // @@protoc_insertion_point(field_add:pb.GatingHierarchy.transFlag)
  return transflag_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >&
GatingHierarchy::transflag() const {
  // @@protoc_insertion_point(field_list:pb.GatingHierarchy.transFlag)
  return transflag_;
}

// .pb.trans_local trans = 5;
inline bool GatingHierarchy::has_trans() const {
  return this != internal_default_instance() && trans_ != nullptr;
}
inline void GatingHierarchy::clear_trans() {
  if (GetArenaNoVirtual() == nullptr && trans_ != nullptr) {
    delete trans_;
  }
  trans_ = nullptr;
}
inline const ::pb::trans_local& GatingHierarchy::trans() const {
  const ::pb::trans_local* p = trans_;
  // @@protoc_insertion_point(field_get:pb.GatingHierarchy.trans)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::trans_local*>(
      &::pb::_trans_local_default_instance_);
}
inline ::pb::trans_local* GatingHierarchy::release_trans() {
  // @@protoc_insertion_point(field_release:pb.GatingHierarchy.trans)
  
  ::pb::trans_local* temp = trans_;
  trans_ = nullptr;
  return temp;
}
inline ::pb::trans_local* GatingHierarchy::mutable_trans() {
  
  if (trans_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::trans_local>(GetArenaNoVirtual());
    trans_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.trans)
  return trans_;
}
inline void GatingHierarchy::set_allocated_trans(::pb::trans_local* trans) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete trans_;
  }
  if (trans) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      trans = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trans, submessage_arena);
    }
    
  } else {
    
  }
  trans_ = trans;
  // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.trans)
}

// .pb.CytoFrame frame = 6;
inline bool GatingHierarchy::has_frame() const {
  return this != internal_default_instance() && frame_ != nullptr;
}
inline void GatingHierarchy::clear_frame() {
  if (GetArenaNoVirtual() == nullptr && frame_ != nullptr) {
    delete frame_;
  }
  frame_ = nullptr;
}
inline const ::pb::CytoFrame& GatingHierarchy::frame() const {
  const ::pb::CytoFrame* p = frame_;
  // @@protoc_insertion_point(field_get:pb.GatingHierarchy.frame)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::CytoFrame*>(
      &::pb::_CytoFrame_default_instance_);
}
inline ::pb::CytoFrame* GatingHierarchy::release_frame() {
  // @@protoc_insertion_point(field_release:pb.GatingHierarchy.frame)
  
  ::pb::CytoFrame* temp = frame_;
  frame_ = nullptr;
  return temp;
}
inline ::pb::CytoFrame* GatingHierarchy::mutable_frame() {
  
  if (frame_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::CytoFrame>(GetArenaNoVirtual());
    frame_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.frame)
  return frame_;
}
inline void GatingHierarchy::set_allocated_frame(::pb::CytoFrame* frame) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete frame_;
  }
  if (frame) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, frame, submessage_arena);
    }
    
  } else {
    
  }
  frame_ = frame;
  // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.frame)
}

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

// CytoFrame

// bool is_h5 = 1;
inline void CytoFrame::clear_is_h5() {
  is_h5_ = false;
}
inline bool CytoFrame::is_h5() const {
  // @@protoc_insertion_point(field_get:pb.CytoFrame.is_h5)
  return is_h5_;
}
inline void CytoFrame::set_is_h5(bool value) {
  
  is_h5_ = value;
  // @@protoc_insertion_point(field_set:pb.CytoFrame.is_h5)
}

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

// TRANS_TBL

// uint64 trans_address = 1;
inline void TRANS_TBL::clear_trans_address() {
  trans_address_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TRANS_TBL::trans_address() const {
  // @@protoc_insertion_point(field_get:pb.TRANS_TBL.trans_address)
  return trans_address_;
}
inline void TRANS_TBL::set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  trans_address_ = value;
  // @@protoc_insertion_point(field_set:pb.TRANS_TBL.trans_address)
}

// .pb.transformation trans = 2;
inline bool TRANS_TBL::has_trans() const {
  return this != internal_default_instance() && trans_ != nullptr;
}
inline void TRANS_TBL::clear_trans() {
  if (GetArenaNoVirtual() == nullptr && trans_ != nullptr) {
    delete trans_;
  }
  trans_ = nullptr;
}
inline const ::pb::transformation& TRANS_TBL::trans() const {
  const ::pb::transformation* p = trans_;
  // @@protoc_insertion_point(field_get:pb.TRANS_TBL.trans)
  return p != nullptr ? *p : *reinterpret_cast<const ::pb::transformation*>(
      &::pb::_transformation_default_instance_);
}
inline ::pb::transformation* TRANS_TBL::release_trans() {
  // @@protoc_insertion_point(field_release:pb.TRANS_TBL.trans)
  
  ::pb::transformation* temp = trans_;
  trans_ = nullptr;
  return temp;
}
inline ::pb::transformation* TRANS_TBL::mutable_trans() {
  
  if (trans_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::transformation>(GetArenaNoVirtual());
    trans_ = p;
  }
  // @@protoc_insertion_point(field_mutable:pb.TRANS_TBL.trans)
  return trans_;
}
inline void TRANS_TBL::set_allocated_trans(::pb::transformation* trans) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete trans_;
  }
  if (trans) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      trans = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trans, submessage_arena);
    }
    
  } else {
    
  }
  trans_ = trans;
  // @@protoc_insertion_point(field_set_allocated:pb.TRANS_TBL.trans)
}

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

// GatingSet

// repeated .pb.TRANS_TBL trans_tbl = 2;
inline int GatingSet::trans_tbl_size() const {
  return trans_tbl_.size();
}
inline void GatingSet::clear_trans_tbl() {
  trans_tbl_.Clear();
}
inline ::pb::TRANS_TBL* GatingSet::mutable_trans_tbl(int index) {
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.trans_tbl)
  return trans_tbl_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >*
GatingSet::mutable_trans_tbl() {
  // @@protoc_insertion_point(field_mutable_list:pb.GatingSet.trans_tbl)
  return &trans_tbl_;
}
inline const ::pb::TRANS_TBL& GatingSet::trans_tbl(int index) const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.trans_tbl)
  return trans_tbl_.Get(index);
}
inline ::pb::TRANS_TBL* GatingSet::add_trans_tbl() {
  // @@protoc_insertion_point(field_add:pb.GatingSet.trans_tbl)
  return trans_tbl_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >&
GatingSet::trans_tbl() const {
  // @@protoc_insertion_point(field_list:pb.GatingSet.trans_tbl)
  return trans_tbl_;
}

// repeated string sampleName = 1;
inline int GatingSet::samplename_size() const {
  return samplename_.size();
}
inline void GatingSet::clear_samplename() {
  samplename_.Clear();
}
inline const std::string& GatingSet::samplename(int index) const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.sampleName)
  return samplename_.Get(index);
}
inline std::string* GatingSet::mutable_samplename(int index) {
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.sampleName)
  return samplename_.Mutable(index);
}
inline void GatingSet::set_samplename(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.GatingSet.sampleName)
  samplename_.Mutable(index)->assign(value);
}
inline void GatingSet::set_samplename(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.GatingSet.sampleName)
  samplename_.Mutable(index)->assign(std::move(value));
}
inline void GatingSet::set_samplename(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  samplename_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.GatingSet.sampleName)
}
inline void GatingSet::set_samplename(int index, const char* value, size_t size) {
  samplename_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.sampleName)
}
inline std::string* GatingSet::add_samplename() {
  // @@protoc_insertion_point(field_add_mutable:pb.GatingSet.sampleName)
  return samplename_.Add();
}
inline void GatingSet::add_samplename(const std::string& value) {
  samplename_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.GatingSet.sampleName)
}
inline void GatingSet::add_samplename(std::string&& value) {
  samplename_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.GatingSet.sampleName)
}
inline void GatingSet::add_samplename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  samplename_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.GatingSet.sampleName)
}
inline void GatingSet::add_samplename(const char* value, size_t size) {
  samplename_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.GatingSet.sampleName)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
GatingSet::samplename() const {
  // @@protoc_insertion_point(field_list:pb.GatingSet.sampleName)
  return samplename_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
GatingSet::mutable_samplename() {
  // @@protoc_insertion_point(field_mutable_list:pb.GatingSet.sampleName)
  return &samplename_;
}

// uint64 globalBiExpTrans = 3;
inline void GatingSet::clear_globalbiexptrans() {
  globalbiexptrans_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 GatingSet::globalbiexptrans() const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.globalBiExpTrans)
  return globalbiexptrans_;
}
inline void GatingSet::set_globalbiexptrans(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  globalbiexptrans_ = value;
  // @@protoc_insertion_point(field_set:pb.GatingSet.globalBiExpTrans)
}

// uint64 globalLinTrans = 4;
inline void GatingSet::clear_globallintrans() {
  globallintrans_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 GatingSet::globallintrans() const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.globalLinTrans)
  return globallintrans_;
}
inline void GatingSet::set_globallintrans(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  globallintrans_ = value;
  // @@protoc_insertion_point(field_set:pb.GatingSet.globalLinTrans)
}

// repeated .pb.trans_local gTrans = 5;
inline int GatingSet::gtrans_size() const {
  return gtrans_.size();
}
inline void GatingSet::clear_gtrans() {
  gtrans_.Clear();
}
inline ::pb::trans_local* GatingSet::mutable_gtrans(int index) {
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.gTrans)
  return gtrans_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >*
GatingSet::mutable_gtrans() {
  // @@protoc_insertion_point(field_mutable_list:pb.GatingSet.gTrans)
  return &gtrans_;
}
inline const ::pb::trans_local& GatingSet::gtrans(int index) const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.gTrans)
  return gtrans_.Get(index);
}
inline ::pb::trans_local* GatingSet::add_gtrans() {
  // @@protoc_insertion_point(field_add:pb.GatingSet.gTrans)
  return gtrans_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >&
GatingSet::gtrans() const {
  // @@protoc_insertion_point(field_list:pb.GatingSet.gTrans)
  return gtrans_;
}

// string guid = 6;
inline void GatingSet::clear_guid() {
  guid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GatingSet::guid() const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.guid)
  return guid_.GetNoArena();
}
inline void GatingSet::set_guid(const std::string& value) {
  
  guid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.GatingSet.guid)
}
inline void GatingSet::set_guid(std::string&& value) {
  
  guid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.guid)
}
inline void GatingSet::set_guid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  guid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.GatingSet.guid)
}
inline void GatingSet::set_guid(const char* value, size_t size) {
  
  guid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.guid)
}
inline std::string* GatingSet::mutable_guid() {
  
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.guid)
  return guid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GatingSet::release_guid() {
  // @@protoc_insertion_point(field_release:pb.GatingSet.guid)
  
  return guid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GatingSet::set_allocated_guid(std::string* guid) {
  if (guid != nullptr) {
    
  } else {
    
  }
  guid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), guid);
  // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.guid)
}

// string cytolib_verion = 7;
inline void GatingSet::clear_cytolib_verion() {
  cytolib_verion_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GatingSet::cytolib_verion() const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.cytolib_verion)
  return cytolib_verion_.GetNoArena();
}
inline void GatingSet::set_cytolib_verion(const std::string& value) {
  
  cytolib_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.GatingSet.cytolib_verion)
}
inline void GatingSet::set_cytolib_verion(std::string&& value) {
  
  cytolib_verion_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.cytolib_verion)
}
inline void GatingSet::set_cytolib_verion(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cytolib_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.GatingSet.cytolib_verion)
}
inline void GatingSet::set_cytolib_verion(const char* value, size_t size) {
  
  cytolib_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.cytolib_verion)
}
inline std::string* GatingSet::mutable_cytolib_verion() {
  
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.cytolib_verion)
  return cytolib_verion_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GatingSet::release_cytolib_verion() {
  // @@protoc_insertion_point(field_release:pb.GatingSet.cytolib_verion)
  
  return cytolib_verion_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GatingSet::set_allocated_cytolib_verion(std::string* cytolib_verion) {
  if (cytolib_verion != nullptr) {
    
  } else {
    
  }
  cytolib_verion_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cytolib_verion);
  // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.cytolib_verion)
}

// string pb_verion = 8;
inline void GatingSet::clear_pb_verion() {
  pb_verion_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GatingSet::pb_verion() const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.pb_verion)
  return pb_verion_.GetNoArena();
}
inline void GatingSet::set_pb_verion(const std::string& value) {
  
  pb_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.GatingSet.pb_verion)
}
inline void GatingSet::set_pb_verion(std::string&& value) {
  
  pb_verion_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.pb_verion)
}
inline void GatingSet::set_pb_verion(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  pb_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.GatingSet.pb_verion)
}
inline void GatingSet::set_pb_verion(const char* value, size_t size) {
  
  pb_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.pb_verion)
}
inline std::string* GatingSet::mutable_pb_verion() {
  
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.pb_verion)
  return pb_verion_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GatingSet::release_pb_verion() {
  // @@protoc_insertion_point(field_release:pb.GatingSet.pb_verion)
  
  return pb_verion_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GatingSet::set_allocated_pb_verion(std::string* pb_verion) {
  if (pb_verion != nullptr) {
    
  } else {
    
  }
  pb_verion_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pb_verion);
  // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.pb_verion)
}

// string h5_verion = 9;
inline void GatingSet::clear_h5_verion() {
  h5_verion_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GatingSet::h5_verion() const {
  // @@protoc_insertion_point(field_get:pb.GatingSet.h5_verion)
  return h5_verion_.GetNoArena();
}
inline void GatingSet::set_h5_verion(const std::string& value) {
  
  h5_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:pb.GatingSet.h5_verion)
}
inline void GatingSet::set_h5_verion(std::string&& value) {
  
  h5_verion_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.h5_verion)
}
inline void GatingSet::set_h5_verion(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  h5_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:pb.GatingSet.h5_verion)
}
inline void GatingSet::set_h5_verion(const char* value, size_t size) {
  
  h5_verion_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.h5_verion)
}
inline std::string* GatingSet::mutable_h5_verion() {
  
  // @@protoc_insertion_point(field_mutable:pb.GatingSet.h5_verion)
  return h5_verion_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GatingSet::release_h5_verion() {
  // @@protoc_insertion_point(field_release:pb.GatingSet.h5_verion)
  
  return h5_verion_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GatingSet::set_allocated_h5_verion(std::string* h5_verion) {
  if (h5_verion != nullptr) {
    
  } else {
    
  }
  h5_verion_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), h5_verion);
  // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.h5_verion)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace pb

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::pb::QUADRANT> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pb::QUADRANT>() {
  return ::pb::QUADRANT_descriptor();
}
template <> struct is_proto_enum< ::pb::GATE_TYPE> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pb::GATE_TYPE>() {
  return ::pb::GATE_TYPE_descriptor();
}
template <> struct is_proto_enum< ::pb::ind_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pb::ind_type>() {
  return ::pb::ind_type_descriptor();
}
template <> struct is_proto_enum< ::pb::TRANS_TYPE> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pb::TRANS_TYPE>() {
  return ::pb::TRANS_TYPE_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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