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

#include <cytolib/GatingSet.pb.h>

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BOOL_GATE_OP_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_COMP_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CytoFrame_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PARAM_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPINDICES_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPSTATS_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TRANS_TBL_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_biexpTrans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_boolGate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_calibrationTable_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_clusterGate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_coordinate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ellipseGate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_fasinhTrans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_flinTrans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_gate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logGML2Trans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logTrans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logicleTrans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_nodeProperties_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_paramPoly_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_paramRange_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_polygonGate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_populationTree_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_quadGate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_rangeGate_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_scaleTrans_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_local_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_pair_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<8> scc_info_transformation_GatingSet_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_treeNodes_GatingSet_2eproto;
namespace pb {
class paramRangeDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<paramRange> _instance;
} _paramRange_default_instance_;
class rangeGateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<rangeGate> _instance;
} _rangeGate_default_instance_;
class paramPolyDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<paramPoly> _instance;
} _paramPoly_default_instance_;
class polygonGateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<polygonGate> _instance;
} _polygonGate_default_instance_;
class coordinateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<coordinate> _instance;
} _coordinate_default_instance_;
class ellipseGateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ellipseGate> _instance;
} _ellipseGate_default_instance_;
class BOOL_GATE_OPDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BOOL_GATE_OP> _instance;
} _BOOL_GATE_OP_default_instance_;
class boolGateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<boolGate> _instance;
} _boolGate_default_instance_;
class clusterGateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<clusterGate> _instance;
} _clusterGate_default_instance_;
class quadGateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<quadGate> _instance;
} _quadGate_default_instance_;
class gateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<gate> _instance;
} _gate_default_instance_;
class POPSTATSDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<POPSTATS> _instance;
} _POPSTATS_default_instance_;
class calibrationTableDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<calibrationTable> _instance;
} _calibrationTable_default_instance_;
class biexpTransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<biexpTrans> _instance;
} _biexpTrans_default_instance_;
class fasinhTransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<fasinhTrans> _instance;
} _fasinhTrans_default_instance_;
class scaleTransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<scaleTrans> _instance;
} _scaleTrans_default_instance_;
class flinTransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<flinTrans> _instance;
} _flinTrans_default_instance_;
class logTransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<logTrans> _instance;
} _logTrans_default_instance_;
class logGML2TransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<logGML2Trans> _instance;
} _logGML2Trans_default_instance_;
class logicleTransDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<logicleTrans> _instance;
} _logicleTrans_default_instance_;
class transformationDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<transformation> _instance;
} _transformation_default_instance_;
class trans_pairDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<trans_pair> _instance;
} _trans_pair_default_instance_;
class trans_localDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<trans_local> _instance;
} _trans_local_default_instance_;
class POPINDICESDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<POPINDICES> _instance;
} _POPINDICES_default_instance_;
class nodePropertiesDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<nodeProperties> _instance;
} _nodeProperties_default_instance_;
class treeNodesDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<treeNodes> _instance;
} _treeNodes_default_instance_;
class populationTreeDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<populationTree> _instance;
} _populationTree_default_instance_;
class COMPDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<COMP> _instance;
} _COMP_default_instance_;
class PARAMDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PARAM> _instance;
} _PARAM_default_instance_;
class GatingHierarchyDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<GatingHierarchy> _instance;
} _GatingHierarchy_default_instance_;
class CytoFrameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CytoFrame> _instance;
} _CytoFrame_default_instance_;
class TRANS_TBLDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TRANS_TBL> _instance;
} _TRANS_TBL_default_instance_;
class GatingSetDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<GatingSet> _instance;
} _GatingSet_default_instance_;
}  // namespace pb
static void InitDefaultsscc_info_BOOL_GATE_OP_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_BOOL_GATE_OP_default_instance_;
    new (ptr) ::pb::BOOL_GATE_OP();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::BOOL_GATE_OP::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BOOL_GATE_OP_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_BOOL_GATE_OP_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_COMP_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_COMP_default_instance_;
    new (ptr) ::pb::COMP();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::COMP::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_COMP_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_COMP_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_CytoFrame_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_CytoFrame_default_instance_;
    new (ptr) ::pb::CytoFrame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::CytoFrame::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CytoFrame_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CytoFrame_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_GatingHierarchy_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_GatingHierarchy_default_instance_;
    new (ptr) ::pb::GatingHierarchy();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::GatingHierarchy::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_GatingHierarchy_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, InitDefaultsscc_info_GatingHierarchy_GatingSet_2eproto}, {
      &scc_info_populationTree_GatingSet_2eproto.base,
      &scc_info_COMP_GatingSet_2eproto.base,
      &scc_info_PARAM_GatingSet_2eproto.base,
      &scc_info_trans_local_GatingSet_2eproto.base,
      &scc_info_CytoFrame_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_GatingSet_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_GatingSet_default_instance_;
    new (ptr) ::pb::GatingSet();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::GatingSet::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_GatingSet_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_GatingSet_GatingSet_2eproto}, {
      &scc_info_TRANS_TBL_GatingSet_2eproto.base,
      &scc_info_trans_local_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_PARAM_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_PARAM_default_instance_;
    new (ptr) ::pb::PARAM();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::PARAM::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PARAM_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_PARAM_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_POPINDICES_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_POPINDICES_default_instance_;
    new (ptr) ::pb::POPINDICES();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::POPINDICES::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPINDICES_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_POPINDICES_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_POPSTATS_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_POPSTATS_default_instance_;
    new (ptr) ::pb::POPSTATS();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::POPSTATS::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPSTATS_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_POPSTATS_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_TRANS_TBL_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_TRANS_TBL_default_instance_;
    new (ptr) ::pb::TRANS_TBL();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::TRANS_TBL::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TRANS_TBL_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TRANS_TBL_GatingSet_2eproto}, {
      &scc_info_transformation_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_biexpTrans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_biexpTrans_default_instance_;
    new (ptr) ::pb::biexpTrans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::biexpTrans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_biexpTrans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_biexpTrans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_boolGate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_boolGate_default_instance_;
    new (ptr) ::pb::boolGate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::boolGate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_boolGate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_boolGate_GatingSet_2eproto}, {
      &scc_info_BOOL_GATE_OP_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_calibrationTable_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_calibrationTable_default_instance_;
    new (ptr) ::pb::calibrationTable();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::calibrationTable::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_calibrationTable_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_calibrationTable_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_clusterGate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_clusterGate_default_instance_;
    new (ptr) ::pb::clusterGate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::clusterGate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_clusterGate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_clusterGate_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_coordinate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_coordinate_default_instance_;
    new (ptr) ::pb::coordinate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::coordinate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_coordinate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_coordinate_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_ellipseGate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_ellipseGate_default_instance_;
    new (ptr) ::pb::ellipseGate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::ellipseGate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ellipseGate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_ellipseGate_GatingSet_2eproto}, {
      &scc_info_coordinate_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_fasinhTrans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_fasinhTrans_default_instance_;
    new (ptr) ::pb::fasinhTrans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::fasinhTrans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_fasinhTrans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_fasinhTrans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_flinTrans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_flinTrans_default_instance_;
    new (ptr) ::pb::flinTrans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::flinTrans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_flinTrans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_flinTrans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_gate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_gate_default_instance_;
    new (ptr) ::pb::gate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::gate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_gate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, InitDefaultsscc_info_gate_GatingSet_2eproto}, {
      &scc_info_rangeGate_GatingSet_2eproto.base,
      &scc_info_polygonGate_GatingSet_2eproto.base,
      &scc_info_ellipseGate_GatingSet_2eproto.base,
      &scc_info_boolGate_GatingSet_2eproto.base,
      &scc_info_clusterGate_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_logGML2Trans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_logGML2Trans_default_instance_;
    new (ptr) ::pb::logGML2Trans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::logGML2Trans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logGML2Trans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_logGML2Trans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_logTrans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_logTrans_default_instance_;
    new (ptr) ::pb::logTrans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::logTrans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logTrans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_logTrans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_logicleTrans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_logicleTrans_default_instance_;
    new (ptr) ::pb::logicleTrans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::logicleTrans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logicleTrans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_logicleTrans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_nodeProperties_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_nodeProperties_default_instance_;
    new (ptr) ::pb::nodeProperties();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::nodeProperties::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_nodeProperties_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_nodeProperties_GatingSet_2eproto}, {
      &scc_info_POPSTATS_GatingSet_2eproto.base,
      &scc_info_POPINDICES_GatingSet_2eproto.base,
      &scc_info_gate_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_paramPoly_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_paramPoly_default_instance_;
    new (ptr) ::pb::paramPoly();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::paramPoly::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_paramPoly_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_paramPoly_GatingSet_2eproto}, {
      &scc_info_coordinate_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_paramRange_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_paramRange_default_instance_;
    new (ptr) ::pb::paramRange();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::paramRange::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_paramRange_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_paramRange_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_polygonGate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_polygonGate_default_instance_;
    new (ptr) ::pb::polygonGate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::polygonGate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_polygonGate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_polygonGate_GatingSet_2eproto}, {
      &scc_info_paramPoly_GatingSet_2eproto.base,
      &scc_info_quadGate_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_populationTree_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_populationTree_default_instance_;
    new (ptr) ::pb::populationTree();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::populationTree::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_populationTree_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_populationTree_GatingSet_2eproto}, {
      &scc_info_treeNodes_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_quadGate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_quadGate_default_instance_;
    new (ptr) ::pb::quadGate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::quadGate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_quadGate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_quadGate_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_rangeGate_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_rangeGate_default_instance_;
    new (ptr) ::pb::rangeGate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::rangeGate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_rangeGate_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_rangeGate_GatingSet_2eproto}, {
      &scc_info_paramRange_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_scaleTrans_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_scaleTrans_default_instance_;
    new (ptr) ::pb::scaleTrans();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::scaleTrans::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_scaleTrans_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_scaleTrans_GatingSet_2eproto}, {}};

static void InitDefaultsscc_info_trans_local_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_trans_local_default_instance_;
    new (ptr) ::pb::trans_local();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::trans_local::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_local_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_trans_local_GatingSet_2eproto}, {
      &scc_info_trans_pair_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_trans_pair_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_trans_pair_default_instance_;
    new (ptr) ::pb::trans_pair();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::trans_pair::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_pair_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_trans_pair_GatingSet_2eproto}, {
      &scc_info_transformation_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_transformation_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_transformation_default_instance_;
    new (ptr) ::pb::transformation();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::transformation::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<8> scc_info_transformation_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 8, InitDefaultsscc_info_transformation_GatingSet_2eproto}, {
      &scc_info_calibrationTable_GatingSet_2eproto.base,
      &scc_info_biexpTrans_GatingSet_2eproto.base,
      &scc_info_logTrans_GatingSet_2eproto.base,
      &scc_info_flinTrans_GatingSet_2eproto.base,
      &scc_info_scaleTrans_GatingSet_2eproto.base,
      &scc_info_fasinhTrans_GatingSet_2eproto.base,
      &scc_info_logicleTrans_GatingSet_2eproto.base,
      &scc_info_logGML2Trans_GatingSet_2eproto.base,}};

static void InitDefaultsscc_info_treeNodes_GatingSet_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::pb::_treeNodes_default_instance_;
    new (ptr) ::pb::treeNodes();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::pb::treeNodes::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_treeNodes_GatingSet_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_treeNodes_GatingSet_2eproto}, {
      &scc_info_nodeProperties_GatingSet_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_GatingSet_2eproto[33];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_GatingSet_2eproto[4];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_GatingSet_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_GatingSet_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::paramRange, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::paramRange, name_),
  PROTOBUF_FIELD_OFFSET(::pb::paramRange, min_),
  PROTOBUF_FIELD_OFFSET(::pb::paramRange, max_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::rangeGate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::rangeGate, param_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::paramPoly, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::paramPoly, params_),
  PROTOBUF_FIELD_OFFSET(::pb::paramPoly, vertices_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::polygonGate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::polygonGate, param_),
  PROTOBUF_FIELD_OFFSET(::pb::polygonGate, qg_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::coordinate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::coordinate, x_),
  PROTOBUF_FIELD_OFFSET(::pb::coordinate, y_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, mu_),
  PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, cov_),
  PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, antipodal_vertices_),
  PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, dist_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, path_),
  PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, op_),
  PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, isnot_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::boolGate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::boolGate, boolopspec_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::clusterGate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::clusterGate, cluster_method_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::quadGate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::quadGate, uid_),
  PROTOBUF_FIELD_OFFSET(::pb::quadGate, quadrant_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::gate, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::gate, neg_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, istransformed_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, isgained_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, type_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, rg_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, pg_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, eg_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, bg_),
  PROTOBUF_FIELD_OFFSET(::pb::gate, cg_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, stattype_),
  PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, statval_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, x_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, y_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, b_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, c_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, d_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, spline_method_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, caltype_),
  PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, flag_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, channelrange_),
  PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, pos_),
  PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, neg_),
  PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, widthbasis_),
  PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, maxvalue_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, length_),
  PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, maxrange_),
  PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, t_),
  PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, a_),
  PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, m_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, scale_factor_),
  PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, t_scale_),
  PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, r_scale_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::flinTrans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::flinTrans, min_),
  PROTOBUF_FIELD_OFFSET(::pb::flinTrans, max_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::logTrans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::logTrans, offset_),
  PROTOBUF_FIELD_OFFSET(::pb::logTrans, decade_),
  PROTOBUF_FIELD_OFFSET(::pb::logTrans, t_),
  PROTOBUF_FIELD_OFFSET(::pb::logTrans, scale_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, t_),
  PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, m_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, t_),
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, w_),
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, m_),
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, a_),
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, bins_),
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, isgml2_),
  PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, isinverse_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::transformation, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::transformation, caltbl_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, isgateonly_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, name_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, channel_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, iscomputed_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, type_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, trans_type_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, bt_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, lt_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, flt_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, st_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, ft_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, lgt_),
  PROTOBUF_FIELD_OFFSET(::pb::transformation, lgml2t_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::trans_pair, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::trans_pair, name_),
  PROTOBUF_FIELD_OFFSET(::pb::trans_pair, trans_address_),
  PROTOBUF_FIELD_OFFSET(::pb::trans_pair, trans_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::trans_local, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::trans_local, tp_),
  PROTOBUF_FIELD_OFFSET(::pb::trans_local, groupname_),
  PROTOBUF_FIELD_OFFSET(::pb::trans_local, sampleids_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, nevents_),
  PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, indtype_),
  PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, iind_),
  PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, bind_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, thisname_),
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, fjstats_),
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, fcstats_),
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, hidden_),
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, indices_),
  PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, thisgate_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::treeNodes, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::treeNodes, node_),
  PROTOBUF_FIELD_OFFSET(::pb::treeNodes, parent_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::populationTree, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::populationTree, node_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::COMP, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::COMP, cid_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, prefix_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, suffix_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, name_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, comment_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, marker_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, spillover_),
  PROTOBUF_FIELD_OFFSET(::pb::COMP, detector_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::PARAM, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::PARAM, param_),
  PROTOBUF_FIELD_OFFSET(::pb::PARAM, log_),
  PROTOBUF_FIELD_OFFSET(::pb::PARAM, range_),
  PROTOBUF_FIELD_OFFSET(::pb::PARAM, highvalue_),
  PROTOBUF_FIELD_OFFSET(::pb::PARAM, calibrationindex_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, tree_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, comp_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, isloaded_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, transflag_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, trans_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, frame_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::CytoFrame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::CytoFrame, is_h5_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, trans_address_),
  PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, trans_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, trans_tbl_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, samplename_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, globalbiexptrans_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, globallintrans_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, gtrans_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, guid_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, cytolib_verion_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, pb_verion_),
  PROTOBUF_FIELD_OFFSET(::pb::GatingSet, h5_verion_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, sizeof(::pb::paramRange)},
  { 8, -1, sizeof(::pb::rangeGate)},
  { 14, -1, sizeof(::pb::paramPoly)},
  { 21, -1, sizeof(::pb::polygonGate)},
  { 28, -1, sizeof(::pb::coordinate)},
  { 35, -1, sizeof(::pb::ellipseGate)},
  { 44, -1, sizeof(::pb::BOOL_GATE_OP)},
  { 52, -1, sizeof(::pb::boolGate)},
  { 58, -1, sizeof(::pb::clusterGate)},
  { 64, -1, sizeof(::pb::quadGate)},
  { 71, -1, sizeof(::pb::gate)},
  { 85, -1, sizeof(::pb::POPSTATS)},
  { 92, -1, sizeof(::pb::calibrationTable)},
  { 105, -1, sizeof(::pb::biexpTrans)},
  { 115, -1, sizeof(::pb::fasinhTrans)},
  { 125, -1, sizeof(::pb::scaleTrans)},
  { 133, -1, sizeof(::pb::flinTrans)},
  { 140, -1, sizeof(::pb::logTrans)},
  { 149, -1, sizeof(::pb::logGML2Trans)},
  { 156, -1, sizeof(::pb::logicleTrans)},
  { 168, -1, sizeof(::pb::transformation)},
  { 187, -1, sizeof(::pb::trans_pair)},
  { 195, -1, sizeof(::pb::trans_local)},
  { 203, -1, sizeof(::pb::POPINDICES)},
  { 212, -1, sizeof(::pb::nodeProperties)},
  { 223, -1, sizeof(::pb::treeNodes)},
  { 230, -1, sizeof(::pb::populationTree)},
  { 236, -1, sizeof(::pb::COMP)},
  { 249, -1, sizeof(::pb::PARAM)},
  { 259, -1, sizeof(::pb::GatingHierarchy)},
  { 270, -1, sizeof(::pb::CytoFrame)},
  { 276, -1, sizeof(::pb::TRANS_TBL)},
  { 283, -1, sizeof(::pb::GatingSet)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_paramRange_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_rangeGate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_paramPoly_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_polygonGate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_coordinate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_ellipseGate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_BOOL_GATE_OP_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_boolGate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_clusterGate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_quadGate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_gate_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_POPSTATS_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_calibrationTable_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_biexpTrans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_fasinhTrans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_scaleTrans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_flinTrans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_logTrans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_logGML2Trans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_logicleTrans_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_transformation_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_trans_pair_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_trans_local_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_POPINDICES_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_nodeProperties_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_treeNodes_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_populationTree_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_COMP_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_PARAM_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_GatingHierarchy_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_CytoFrame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_TRANS_TBL_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::pb::_GatingSet_default_instance_),
};

const char descriptor_table_protodef_GatingSet_2eproto[] =
  "\n\017GatingSet.proto\022\002pb\"4\n\nparamRange\022\014\n\004n"
  "ame\030\001 \001(\t\022\013\n\003min\030\002 \001(\002\022\013\n\003max\030\003 \001(\002\"*\n\tr"
  "angeGate\022\035\n\005param\030\001 \001(\0132\016.pb.paramRange\""
  "=\n\tparamPoly\022\016\n\006params\030\001 \003(\t\022 \n\010vertices"
  "\030\002 \003(\0132\016.pb.coordinate\"E\n\013polygonGate\022\034\n"
  "\005param\030\001 \001(\0132\r.pb.paramPoly\022\030\n\002qg\030\002 \001(\0132"
  "\014.pb.quadGate\"\"\n\ncoordinate\022\t\n\001x\030\001 \001(\002\022\t"
  "\n\001y\030\002 \001(\002\"\200\001\n\013ellipseGate\022\032\n\002mu\030\001 \001(\0132\016."
  "pb.coordinate\022\033\n\003cov\030\002 \003(\0132\016.pb.coordina"
  "te\022*\n\022antipodal_vertices\030\003 \003(\0132\016.pb.coor"
  "dinate\022\014\n\004dist\030\004 \001(\002\"7\n\014BOOL_GATE_OP\022\014\n\004"
  "path\030\001 \003(\t\022\n\n\002op\030\002 \001(\r\022\r\n\005isNot\030\003 \001(\010\"0\n"
  "\010boolGate\022$\n\nboolOpSpec\030\001 \003(\0132\020.pb.BOOL_"
  "GATE_OP\"%\n\013clusterGate\022\026\n\016cluster_method"
  "\030\001 \001(\t\"7\n\010quadGate\022\013\n\003uid\030\001 \001(\t\022\036\n\010quadr"
  "ant\030\003 \001(\0162\014.pb.QUADRANT\"\345\001\n\004gate\022\013\n\003neg\030"
  "\001 \001(\010\022\025\n\risTransformed\030\002 \001(\010\022\020\n\010isGained"
  "\030\003 \001(\010\022\033\n\004type\030\004 \001(\0162\r.pb.GATE_TYPE\022\031\n\002r"
  "g\030\005 \001(\0132\r.pb.rangeGate\022\033\n\002pg\030\006 \001(\0132\017.pb."
  "polygonGate\022\033\n\002eg\030\007 \001(\0132\017.pb.ellipseGate"
  "\022\030\n\002bg\030\010 \001(\0132\014.pb.boolGate\022\033\n\002cg\030\t \001(\0132\017"
  ".pb.clusterGate\"-\n\010POPSTATS\022\020\n\010statType\030"
  "\001 \001(\t\022\017\n\007statVal\030\002 \001(\002\"\223\001\n\020calibrationTa"
  "ble\022\r\n\001x\030\001 \003(\002B\002\020\001\022\r\n\001y\030\002 \003(\002B\002\020\001\022\r\n\001b\030\003"
  " \003(\002B\002\020\001\022\r\n\001c\030\004 \003(\002B\002\020\001\022\r\n\001d\030\005 \003(\002B\002\020\001\022\025"
  "\n\rspline_method\030\006 \001(\r\022\017\n\007caltype\030\007 \001(\t\022\014"
  "\n\004flag\030\010 \001(\010\"b\n\nbiexpTrans\022\024\n\014channelRan"
  "ge\030\001 \001(\r\022\013\n\003pos\030\002 \001(\002\022\013\n\003neg\030\003 \001(\002\022\022\n\nwi"
  "dthBasis\030\004 \001(\002\022\020\n\010maxValue\030\005 \001(\002\"P\n\013fasi"
  "nhTrans\022\016\n\006length\030\001 \001(\002\022\020\n\010maxRange\030\002 \001("
  "\002\022\t\n\001T\030\003 \001(\002\022\t\n\001A\030\004 \001(\002\022\t\n\001M\030\005 \001(\002\"D\n\nsc"
  "aleTrans\022\024\n\014scale_factor\030\001 \001(\002\022\017\n\007t_scal"
  "e\030\002 \001(\002\022\017\n\007r_scale\030\003 \001(\002\"%\n\tflinTrans\022\013\n"
  "\003min\030\001 \001(\002\022\013\n\003max\030\002 \001(\002\"D\n\010logTrans\022\016\n\006o"
  "ffset\030\001 \001(\002\022\016\n\006decade\030\002 \001(\002\022\t\n\001T\030\003 \001(\002\022\r"
  "\n\005scale\030\004 \001(\002\"$\n\014logGML2Trans\022\t\n\001T\030\001 \001(\002"
  "\022\t\n\001M\030\002 \001(\002\"k\n\014logicleTrans\022\t\n\001T\030\001 \001(\002\022\t"
  "\n\001W\030\002 \001(\002\022\t\n\001M\030\003 \001(\002\022\t\n\001A\030\004 \001(\002\022\014\n\004bins\030"
  "\005 \001(\002\022\016\n\006isGml2\030\006 \001(\010\022\021\n\tisInverse\030\007 \001(\010"
  "\"\373\002\n\016transformation\022$\n\006calTbl\030\001 \001(\0132\024.pb"
  ".calibrationTable\022\022\n\nisGateOnly\030\002 \001(\010\022\014\n"
  "\004name\030\004 \001(\t\022\017\n\007channel\030\005 \001(\t\022\022\n\nisComput"
  "ed\030\006 \001(\010\022\014\n\004type\030\014 \001(\r\022\"\n\ntrans_type\030\003 \001"
  "(\0162\016.pb.TRANS_TYPE\022\032\n\002bt\030\007 \001(\0132\016.pb.biex"
  "pTrans\022\030\n\002lt\030\010 \001(\0132\014.pb.logTrans\022\032\n\003flt\030"
  "\t \001(\0132\r.pb.flinTrans\022\032\n\002st\030\n \001(\0132\016.pb.sc"
  "aleTrans\022\033\n\002ft\030\013 \001(\0132\017.pb.fasinhTrans\022\035\n"
  "\003lgt\030\r \001(\0132\020.pb.logicleTrans\022 \n\006lgml2t\030\016"
  " \001(\0132\020.pb.logGML2Trans\"T\n\ntrans_pair\022\014\n\004"
  "name\030\001 \001(\t\022\025\n\rtrans_address\030\002 \001(\004\022!\n\005tra"
  "ns\030\003 \001(\0132\022.pb.transformation\"S\n\013trans_lo"
  "cal\022\032\n\002tp\030\001 \003(\0132\016.pb.trans_pair\022\021\n\tgroup"
  "Name\030\002 \001(\t\022\025\n\tsampleIDs\030\003 \003(\rB\002\020\001\"\\\n\nPOP"
  "INDICES\022\017\n\007nEvents\030\001 \001(\r\022\035\n\007indtype\030\002 \001("
  "\0162\014.pb.ind_type\022\020\n\004iInd\030\003 \003(\rB\002\020\001\022\014\n\004bIn"
  "d\030\004 \001(\014\"\255\001\n\016nodeProperties\022\020\n\010thisName\030\001"
  " \001(\t\022\035\n\007fjStats\030\002 \003(\0132\014.pb.POPSTATS\022\035\n\007f"
  "cStats\030\003 \003(\0132\014.pb.POPSTATS\022\016\n\006hidden\030\004 \001"
  "(\010\022\037\n\007indices\030\005 \001(\0132\016.pb.POPINDICES\022\032\n\010t"
  "hisGate\030\006 \001(\0132\010.pb.gate\"=\n\ttreeNodes\022 \n\004"
  "node\030\001 \001(\0132\022.pb.nodeProperties\022\016\n\006parent"
  "\030\002 \001(\r\"-\n\016populationTree\022\033\n\004node\030\001 \003(\0132\r"
  ".pb.treeNodes\"\207\001\n\004COMP\022\013\n\003cid\030\001 \001(\t\022\016\n\006p"
  "refix\030\002 \001(\t\022\016\n\006suffix\030\003 \001(\t\022\014\n\004name\030\004 \001("
  "\t\022\017\n\007comment\030\005 \001(\t\022\016\n\006marker\030\006 \003(\t\022\021\n\tsp"
  "illOver\030\007 \003(\002\022\020\n\010detector\030\010 \003(\t\"_\n\005PARAM"
  "\022\r\n\005param\030\001 \001(\t\022\013\n\003log\030\002 \001(\010\022\r\n\005range\030\003 "
  "\001(\r\022\021\n\thighValue\030\004 \001(\r\022\030\n\020calibrationInd"
  "ex\030\005 \001(\r\"\271\001\n\017GatingHierarchy\022 \n\004tree\030\002 \001"
  "(\0132\022.pb.populationTree\022\026\n\004comp\030\001 \001(\0132\010.p"
  "b.COMP\022\020\n\010isLoaded\030\003 \001(\010\022\034\n\ttransFlag\030\004 "
  "\003(\0132\t.pb.PARAM\022\036\n\005trans\030\005 \001(\0132\017.pb.trans"
  "_local\022\034\n\005frame\030\006 \001(\0132\r.pb.CytoFrame\"\032\n\t"
  "CytoFrame\022\r\n\005is_h5\030\001 \001(\010\"E\n\tTRANS_TBL\022\025\n"
  "\rtrans_address\030\001 \001(\004\022!\n\005trans\030\002 \001(\0132\022.pb"
  ".transformation\"\340\001\n\tGatingSet\022 \n\ttrans_t"
  "bl\030\002 \003(\0132\r.pb.TRANS_TBL\022\022\n\nsampleName\030\001 "
  "\003(\t\022\030\n\020globalBiExpTrans\030\003 \001(\004\022\026\n\016globalL"
  "inTrans\030\004 \001(\004\022\037\n\006gTrans\030\005 \003(\0132\017.pb.trans"
  "_local\022\014\n\004guid\030\006 \001(\t\022\026\n\016cytolib_verion\030\007"
  " \001(\t\022\021\n\tpb_verion\030\010 \001(\t\022\021\n\th5_verion\030\t \001"
  "(\t*=\n\010QUADRANT\022\021\n\rQ_UNSPECIFIED\020\000\022\006\n\002Q1\020"
  "\001\022\006\n\002Q2\020\002\022\006\n\002Q3\020\003\022\006\n\002Q4\020\004*\272\001\n\tGATE_TYPE\022"
  "\024\n\020GATE_UNSPECIFIED\020\000\022\020\n\014POLYGON_GATE\020\001\022"
  "\016\n\nRANGE_GATE\020\002\022\r\n\tBOOL_GATE\020\003\022\020\n\014ELLIPS"
  "E_GATE\020\004\022\r\n\tRECT_GATE\020\005\022\020\n\014LOGICAL_GATE\020"
  "\006\022\022\n\016ELLIPSOID_GATE\020\007\022\020\n\014CLUSTER_GATE\020\010\022"
  "\r\n\tQUAD_GATE\020\t*\'\n\010ind_type\022\010\n\004BOOL\020\000\022\007\n\003"
  "INT\020\001\022\010\n\004ROOT\020\002*\214\001\n\nTRANS_TYPE\022\r\n\tPB_CAL"
  "TBL\020\000\022\n\n\006PB_LOG\020\001\022\n\n\006PB_LIN\020\002\022\013\n\007PB_FLIN"
  "\020\003\022\016\n\nPB_FASIGNH\020\004\022\014\n\010PB_BIEXP\020\005\022\016\n\nPB_L"
  "OGICLE\020\006\022\016\n\nPB_LOGGML2\020\007\022\014\n\010PB_SCALE\020\010b\006"
  "proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_GatingSet_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_GatingSet_2eproto_sccs[33] = {
  &scc_info_BOOL_GATE_OP_GatingSet_2eproto.base,
  &scc_info_COMP_GatingSet_2eproto.base,
  &scc_info_CytoFrame_GatingSet_2eproto.base,
  &scc_info_GatingHierarchy_GatingSet_2eproto.base,
  &scc_info_GatingSet_GatingSet_2eproto.base,
  &scc_info_PARAM_GatingSet_2eproto.base,
  &scc_info_POPINDICES_GatingSet_2eproto.base,
  &scc_info_POPSTATS_GatingSet_2eproto.base,
  &scc_info_TRANS_TBL_GatingSet_2eproto.base,
  &scc_info_biexpTrans_GatingSet_2eproto.base,
  &scc_info_boolGate_GatingSet_2eproto.base,
  &scc_info_calibrationTable_GatingSet_2eproto.base,
  &scc_info_clusterGate_GatingSet_2eproto.base,
  &scc_info_coordinate_GatingSet_2eproto.base,
  &scc_info_ellipseGate_GatingSet_2eproto.base,
  &scc_info_fasinhTrans_GatingSet_2eproto.base,
  &scc_info_flinTrans_GatingSet_2eproto.base,
  &scc_info_gate_GatingSet_2eproto.base,
  &scc_info_logGML2Trans_GatingSet_2eproto.base,
  &scc_info_logTrans_GatingSet_2eproto.base,
  &scc_info_logicleTrans_GatingSet_2eproto.base,
  &scc_info_nodeProperties_GatingSet_2eproto.base,
  &scc_info_paramPoly_GatingSet_2eproto.base,
  &scc_info_paramRange_GatingSet_2eproto.base,
  &scc_info_polygonGate_GatingSet_2eproto.base,
  &scc_info_populationTree_GatingSet_2eproto.base,
  &scc_info_quadGate_GatingSet_2eproto.base,
  &scc_info_rangeGate_GatingSet_2eproto.base,
  &scc_info_scaleTrans_GatingSet_2eproto.base,
  &scc_info_trans_local_GatingSet_2eproto.base,
  &scc_info_trans_pair_GatingSet_2eproto.base,
  &scc_info_transformation_GatingSet_2eproto.base,
  &scc_info_treeNodes_GatingSet_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_GatingSet_2eproto_once;
static bool descriptor_table_GatingSet_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_GatingSet_2eproto = {
  &descriptor_table_GatingSet_2eproto_initialized, descriptor_table_protodef_GatingSet_2eproto, "GatingSet.proto", 3686,
  &descriptor_table_GatingSet_2eproto_once, descriptor_table_GatingSet_2eproto_sccs, descriptor_table_GatingSet_2eproto_deps, 33, 0,
  schemas, file_default_instances, TableStruct_GatingSet_2eproto::offsets,
  file_level_metadata_GatingSet_2eproto, 33, file_level_enum_descriptors_GatingSet_2eproto, file_level_service_descriptors_GatingSet_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_GatingSet_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_GatingSet_2eproto), true);
namespace pb {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QUADRANT_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto);
  return file_level_enum_descriptors_GatingSet_2eproto[0];
}
bool QUADRANT_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GATE_TYPE_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto);
  return file_level_enum_descriptors_GatingSet_2eproto[1];
}
bool GATE_TYPE_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ind_type_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto);
  return file_level_enum_descriptors_GatingSet_2eproto[2];
}
bool ind_type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TRANS_TYPE_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto);
  return file_level_enum_descriptors_GatingSet_2eproto[3];
}
bool TRANS_TYPE_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}


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

void paramRange::InitAsDefaultInstance() {
}
class paramRange::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int paramRange::kNameFieldNumber;
const int paramRange::kMinFieldNumber;
const int paramRange::kMaxFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

paramRange::paramRange()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.paramRange)
}
paramRange::paramRange(const paramRange& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.name().size() > 0) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  ::memcpy(&min_, &from.min_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_) -
    reinterpret_cast<char*>(&min_)) + sizeof(max_));
  // @@protoc_insertion_point(copy_constructor:pb.paramRange)
}

void paramRange::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_paramRange_GatingSet_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&min_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_) -
      reinterpret_cast<char*>(&min_)) + sizeof(max_));
}

paramRange::~paramRange() {
  // @@protoc_insertion_point(destructor:pb.paramRange)
  SharedDtor();
}

void paramRange::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void paramRange::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const paramRange& paramRange::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_paramRange_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void paramRange::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.paramRange)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&min_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_) -
      reinterpret_cast<char*>(&min_)) + sizeof(max_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* paramRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "pb.paramRange.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float min = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float max = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool paramRange::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.paramRange)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string name = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->name().data(), static_cast<int>(this->name().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.paramRange.name"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float min = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &min_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float max = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &max_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.paramRange)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.paramRange)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void paramRange::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.paramRange)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string name = 1;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.paramRange.name");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // float min = 2;
  if (!(this->min() <= 0 && this->min() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->min(), output);
  }

  // float max = 3;
  if (!(this->max() <= 0 && this->max() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->max(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.paramRange)
}

::PROTOBUF_NAMESPACE_ID::uint8* paramRange::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.paramRange)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string name = 1;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.paramRange.name");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // float min = 2;
  if (!(this->min() <= 0 && this->min() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->min(), target);
  }

  // float max = 3;
  if (!(this->max() <= 0 && this->max() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->max(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.paramRange)
  return target;
}

size_t paramRange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.paramRange)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string name = 1;
  if (this->name().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->name());
  }

  // float min = 2;
  if (!(this->min() <= 0 && this->min() >= 0)) {
    total_size += 1 + 4;
  }

  // float max = 3;
  if (!(this->max() <= 0 && this->max() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void paramRange::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.paramRange)
  GOOGLE_DCHECK_NE(&from, this);
  const paramRange* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<paramRange>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.paramRange)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.paramRange)
    MergeFrom(*source);
  }
}

void paramRange::MergeFrom(const paramRange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.paramRange)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.name().size() > 0) {

    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (!(from.min() <= 0 && from.min() >= 0)) {
    set_min(from.min());
  }
  if (!(from.max() <= 0 && from.max() >= 0)) {
    set_max(from.max());
  }
}

void paramRange::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.paramRange)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void paramRange::CopyFrom(const paramRange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.paramRange)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool paramRange::IsInitialized() const {
  return true;
}

void paramRange::Swap(paramRange* other) {
  if (other == this) return;
  InternalSwap(other);
}
void paramRange::InternalSwap(paramRange* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(min_, other->min_);
  swap(max_, other->max_);
}

::PROTOBUF_NAMESPACE_ID::Metadata paramRange::GetMetadata() const {
  return GetMetadataStatic();
}


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

void rangeGate::InitAsDefaultInstance() {
  ::pb::_rangeGate_default_instance_._instance.get_mutable()->param_ = const_cast< ::pb::paramRange*>(
      ::pb::paramRange::internal_default_instance());
}
class rangeGate::HasBitSetters {
 public:
  static const ::pb::paramRange& param(const rangeGate* msg);
};

const ::pb::paramRange&
rangeGate::HasBitSetters::param(const rangeGate* msg) {
  return *msg->param_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int rangeGate::kParamFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

rangeGate::rangeGate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.rangeGate)
}
rangeGate::rangeGate(const rangeGate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_param()) {
    param_ = new ::pb::paramRange(*from.param_);
  } else {
    param_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:pb.rangeGate)
}

void rangeGate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_rangeGate_GatingSet_2eproto.base);
  param_ = nullptr;
}

rangeGate::~rangeGate() {
  // @@protoc_insertion_point(destructor:pb.rangeGate)
  SharedDtor();
}

void rangeGate::SharedDtor() {
  if (this != internal_default_instance()) delete param_;
}

void rangeGate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const rangeGate& rangeGate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_rangeGate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void rangeGate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.rangeGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && param_ != nullptr) {
    delete param_;
  }
  param_ = nullptr;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* rangeGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .pb.paramRange param = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_param(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool rangeGate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.rangeGate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .pb.paramRange param = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.rangeGate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.rangeGate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void rangeGate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.rangeGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.paramRange param = 1;
  if (this->has_param()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, HasBitSetters::param(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.rangeGate)
}

::PROTOBUF_NAMESPACE_ID::uint8* rangeGate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.rangeGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.paramRange param = 1;
  if (this->has_param()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, HasBitSetters::param(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.rangeGate)
  return target;
}

size_t rangeGate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.rangeGate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .pb.paramRange param = 1;
  if (this->has_param()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *param_);
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void rangeGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.rangeGate)
  GOOGLE_DCHECK_NE(&from, this);
  const rangeGate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<rangeGate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.rangeGate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.rangeGate)
    MergeFrom(*source);
  }
}

void rangeGate::MergeFrom(const rangeGate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.rangeGate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_param()) {
    mutable_param()->::pb::paramRange::MergeFrom(from.param());
  }
}

void rangeGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.rangeGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void rangeGate::CopyFrom(const rangeGate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.rangeGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool rangeGate::IsInitialized() const {
  return true;
}

void rangeGate::Swap(rangeGate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void rangeGate::InternalSwap(rangeGate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(param_, other->param_);
}

::PROTOBUF_NAMESPACE_ID::Metadata rangeGate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void paramPoly::InitAsDefaultInstance() {
}
class paramPoly::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int paramPoly::kParamsFieldNumber;
const int paramPoly::kVerticesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

paramPoly::paramPoly()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.paramPoly)
}
paramPoly::paramPoly(const paramPoly& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      params_(from.params_),
      vertices_(from.vertices_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:pb.paramPoly)
}

void paramPoly::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_paramPoly_GatingSet_2eproto.base);
}

paramPoly::~paramPoly() {
  // @@protoc_insertion_point(destructor:pb.paramPoly)
  SharedDtor();
}

void paramPoly::SharedDtor() {
}

void paramPoly::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const paramPoly& paramPoly::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_paramPoly_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void paramPoly::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.paramPoly)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  params_.Clear();
  vertices_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* paramPoly::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string params = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_params(), ptr, ctx, "pb.paramPoly.params");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      // repeated .pb.coordinate vertices = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_vertices(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool paramPoly::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.paramPoly)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string params = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->add_params()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->params(this->params_size() - 1).data(),
            static_cast<int>(this->params(this->params_size() - 1).length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.paramPoly.params"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.coordinate vertices = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_vertices()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.paramPoly)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.paramPoly)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void paramPoly::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.paramPoly)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string params = 1;
  for (int i = 0, n = this->params_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->params(i).data(), static_cast<int>(this->params(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.paramPoly.params");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
      1, this->params(i), output);
  }

  // repeated .pb.coordinate vertices = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->vertices_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2,
      this->vertices(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.paramPoly)
}

::PROTOBUF_NAMESPACE_ID::uint8* paramPoly::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.paramPoly)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string params = 1;
  for (int i = 0, n = this->params_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->params(i).data(), static_cast<int>(this->params(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.paramPoly.params");
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteStringToArray(1, this->params(i), target);
  }

  // repeated .pb.coordinate vertices = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->vertices_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->vertices(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.paramPoly)
  return target;
}

size_t paramPoly::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.paramPoly)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string params = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->params_size());
  for (int i = 0, n = this->params_size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      this->params(i));
  }

  // repeated .pb.coordinate vertices = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->vertices_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->vertices(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void paramPoly::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.paramPoly)
  GOOGLE_DCHECK_NE(&from, this);
  const paramPoly* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<paramPoly>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.paramPoly)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.paramPoly)
    MergeFrom(*source);
  }
}

void paramPoly::MergeFrom(const paramPoly& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.paramPoly)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  params_.MergeFrom(from.params_);
  vertices_.MergeFrom(from.vertices_);
}

void paramPoly::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.paramPoly)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void paramPoly::CopyFrom(const paramPoly& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.paramPoly)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool paramPoly::IsInitialized() const {
  return true;
}

void paramPoly::Swap(paramPoly* other) {
  if (other == this) return;
  InternalSwap(other);
}
void paramPoly::InternalSwap(paramPoly* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  params_.InternalSwap(CastToBase(&other->params_));
  CastToBase(&vertices_)->InternalSwap(CastToBase(&other->vertices_));
}

::PROTOBUF_NAMESPACE_ID::Metadata paramPoly::GetMetadata() const {
  return GetMetadataStatic();
}


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

void polygonGate::InitAsDefaultInstance() {
  ::pb::_polygonGate_default_instance_._instance.get_mutable()->param_ = const_cast< ::pb::paramPoly*>(
      ::pb::paramPoly::internal_default_instance());
  ::pb::_polygonGate_default_instance_._instance.get_mutable()->qg_ = const_cast< ::pb::quadGate*>(
      ::pb::quadGate::internal_default_instance());
}
class polygonGate::HasBitSetters {
 public:
  static const ::pb::paramPoly& param(const polygonGate* msg);
  static const ::pb::quadGate& qg(const polygonGate* msg);
};

const ::pb::paramPoly&
polygonGate::HasBitSetters::param(const polygonGate* msg) {
  return *msg->param_;
}
const ::pb::quadGate&
polygonGate::HasBitSetters::qg(const polygonGate* msg) {
  return *msg->qg_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int polygonGate::kParamFieldNumber;
const int polygonGate::kQgFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

polygonGate::polygonGate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.polygonGate)
}
polygonGate::polygonGate(const polygonGate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_param()) {
    param_ = new ::pb::paramPoly(*from.param_);
  } else {
    param_ = nullptr;
  }
  if (from.has_qg()) {
    qg_ = new ::pb::quadGate(*from.qg_);
  } else {
    qg_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:pb.polygonGate)
}

void polygonGate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_polygonGate_GatingSet_2eproto.base);
  ::memset(&param_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&qg_) -
      reinterpret_cast<char*>(&param_)) + sizeof(qg_));
}

polygonGate::~polygonGate() {
  // @@protoc_insertion_point(destructor:pb.polygonGate)
  SharedDtor();
}

void polygonGate::SharedDtor() {
  if (this != internal_default_instance()) delete param_;
  if (this != internal_default_instance()) delete qg_;
}

void polygonGate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const polygonGate& polygonGate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_polygonGate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void polygonGate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.polygonGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && param_ != nullptr) {
    delete param_;
  }
  param_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && qg_ != nullptr) {
    delete qg_;
  }
  qg_ = nullptr;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* polygonGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .pb.paramPoly param = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_param(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.quadGate qg = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_qg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool polygonGate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.polygonGate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .pb.paramPoly param = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_param()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.quadGate qg = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_qg()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.polygonGate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.polygonGate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void polygonGate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.polygonGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.paramPoly param = 1;
  if (this->has_param()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, HasBitSetters::param(this), output);
  }

  // .pb.quadGate qg = 2;
  if (this->has_qg()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, HasBitSetters::qg(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.polygonGate)
}

::PROTOBUF_NAMESPACE_ID::uint8* polygonGate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.polygonGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.paramPoly param = 1;
  if (this->has_param()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, HasBitSetters::param(this), target);
  }

  // .pb.quadGate qg = 2;
  if (this->has_qg()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, HasBitSetters::qg(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.polygonGate)
  return target;
}

size_t polygonGate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.polygonGate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .pb.paramPoly param = 1;
  if (this->has_param()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *param_);
  }

  // .pb.quadGate qg = 2;
  if (this->has_qg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *qg_);
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void polygonGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.polygonGate)
  GOOGLE_DCHECK_NE(&from, this);
  const polygonGate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<polygonGate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.polygonGate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.polygonGate)
    MergeFrom(*source);
  }
}

void polygonGate::MergeFrom(const polygonGate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.polygonGate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_param()) {
    mutable_param()->::pb::paramPoly::MergeFrom(from.param());
  }
  if (from.has_qg()) {
    mutable_qg()->::pb::quadGate::MergeFrom(from.qg());
  }
}

void polygonGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.polygonGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void polygonGate::CopyFrom(const polygonGate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.polygonGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool polygonGate::IsInitialized() const {
  return true;
}

void polygonGate::Swap(polygonGate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void polygonGate::InternalSwap(polygonGate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(param_, other->param_);
  swap(qg_, other->qg_);
}

::PROTOBUF_NAMESPACE_ID::Metadata polygonGate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void coordinate::InitAsDefaultInstance() {
}
class coordinate::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int coordinate::kXFieldNumber;
const int coordinate::kYFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

coordinate::coordinate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.coordinate)
}
coordinate::coordinate(const coordinate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&y_) -
    reinterpret_cast<char*>(&x_)) + sizeof(y_));
  // @@protoc_insertion_point(copy_constructor:pb.coordinate)
}

void coordinate::SharedCtor() {
  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&y_) -
      reinterpret_cast<char*>(&x_)) + sizeof(y_));
}

coordinate::~coordinate() {
  // @@protoc_insertion_point(destructor:pb.coordinate)
  SharedDtor();
}

void coordinate::SharedDtor() {
}

void coordinate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const coordinate& coordinate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_coordinate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void coordinate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.coordinate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&y_) -
      reinterpret_cast<char*>(&x_)) + sizeof(y_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* coordinate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool coordinate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.coordinate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float x = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float y = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.coordinate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.coordinate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void coordinate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.coordinate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->x(), output);
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->y(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.coordinate)
}

::PROTOBUF_NAMESPACE_ID::uint8* coordinate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.coordinate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.coordinate)
  return target;
}

size_t coordinate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.coordinate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float x = 1;
  if (!(this->x() <= 0 && this->x() >= 0)) {
    total_size += 1 + 4;
  }

  // float y = 2;
  if (!(this->y() <= 0 && this->y() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void coordinate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.coordinate)
  GOOGLE_DCHECK_NE(&from, this);
  const coordinate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<coordinate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.coordinate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.coordinate)
    MergeFrom(*source);
  }
}

void coordinate::MergeFrom(const coordinate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.coordinate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.x() <= 0 && from.x() >= 0)) {
    set_x(from.x());
  }
  if (!(from.y() <= 0 && from.y() >= 0)) {
    set_y(from.y());
  }
}

void coordinate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.coordinate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void coordinate::CopyFrom(const coordinate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.coordinate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool coordinate::IsInitialized() const {
  return true;
}

void coordinate::Swap(coordinate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void coordinate::InternalSwap(coordinate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(x_, other->x_);
  swap(y_, other->y_);
}

::PROTOBUF_NAMESPACE_ID::Metadata coordinate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void ellipseGate::InitAsDefaultInstance() {
  ::pb::_ellipseGate_default_instance_._instance.get_mutable()->mu_ = const_cast< ::pb::coordinate*>(
      ::pb::coordinate::internal_default_instance());
}
class ellipseGate::HasBitSetters {
 public:
  static const ::pb::coordinate& mu(const ellipseGate* msg);
};

const ::pb::coordinate&
ellipseGate::HasBitSetters::mu(const ellipseGate* msg) {
  return *msg->mu_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ellipseGate::kMuFieldNumber;
const int ellipseGate::kCovFieldNumber;
const int ellipseGate::kAntipodalVerticesFieldNumber;
const int ellipseGate::kDistFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ellipseGate::ellipseGate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.ellipseGate)
}
ellipseGate::ellipseGate(const ellipseGate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      cov_(from.cov_),
      antipodal_vertices_(from.antipodal_vertices_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_mu()) {
    mu_ = new ::pb::coordinate(*from.mu_);
  } else {
    mu_ = nullptr;
  }
  dist_ = from.dist_;
  // @@protoc_insertion_point(copy_constructor:pb.ellipseGate)
}

void ellipseGate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ellipseGate_GatingSet_2eproto.base);
  ::memset(&mu_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&dist_) -
      reinterpret_cast<char*>(&mu_)) + sizeof(dist_));
}

ellipseGate::~ellipseGate() {
  // @@protoc_insertion_point(destructor:pb.ellipseGate)
  SharedDtor();
}

void ellipseGate::SharedDtor() {
  if (this != internal_default_instance()) delete mu_;
}

void ellipseGate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ellipseGate& ellipseGate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ellipseGate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void ellipseGate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.ellipseGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cov_.Clear();
  antipodal_vertices_.Clear();
  if (GetArenaNoVirtual() == nullptr && mu_ != nullptr) {
    delete mu_;
  }
  mu_ = nullptr;
  dist_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ellipseGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .pb.coordinate mu = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_mu(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .pb.coordinate cov = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_cov(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      // repeated .pb.coordinate antipodal_vertices = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_antipodal_vertices(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
        } else goto handle_unusual;
        continue;
      // float dist = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          dist_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ellipseGate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.ellipseGate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .pb.coordinate mu = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_mu()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.coordinate cov = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_cov()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.coordinate antipodal_vertices = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_antipodal_vertices()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float dist = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &dist_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.ellipseGate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.ellipseGate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void ellipseGate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.ellipseGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.coordinate mu = 1;
  if (this->has_mu()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, HasBitSetters::mu(this), output);
  }

  // repeated .pb.coordinate cov = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->cov_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2,
      this->cov(static_cast<int>(i)),
      output);
  }

  // repeated .pb.coordinate antipodal_vertices = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->antipodal_vertices_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3,
      this->antipodal_vertices(static_cast<int>(i)),
      output);
  }

  // float dist = 4;
  if (!(this->dist() <= 0 && this->dist() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->dist(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.ellipseGate)
}

::PROTOBUF_NAMESPACE_ID::uint8* ellipseGate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.ellipseGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.coordinate mu = 1;
  if (this->has_mu()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, HasBitSetters::mu(this), target);
  }

  // repeated .pb.coordinate cov = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->cov_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->cov(static_cast<int>(i)), target);
  }

  // repeated .pb.coordinate antipodal_vertices = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->antipodal_vertices_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->antipodal_vertices(static_cast<int>(i)), target);
  }

  // float dist = 4;
  if (!(this->dist() <= 0 && this->dist() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->dist(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.ellipseGate)
  return target;
}

size_t ellipseGate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.ellipseGate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .pb.coordinate cov = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->cov_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->cov(static_cast<int>(i)));
    }
  }

  // repeated .pb.coordinate antipodal_vertices = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->antipodal_vertices_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->antipodal_vertices(static_cast<int>(i)));
    }
  }

  // .pb.coordinate mu = 1;
  if (this->has_mu()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *mu_);
  }

  // float dist = 4;
  if (!(this->dist() <= 0 && this->dist() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ellipseGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.ellipseGate)
  GOOGLE_DCHECK_NE(&from, this);
  const ellipseGate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ellipseGate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.ellipseGate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.ellipseGate)
    MergeFrom(*source);
  }
}

void ellipseGate::MergeFrom(const ellipseGate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.ellipseGate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cov_.MergeFrom(from.cov_);
  antipodal_vertices_.MergeFrom(from.antipodal_vertices_);
  if (from.has_mu()) {
    mutable_mu()->::pb::coordinate::MergeFrom(from.mu());
  }
  if (!(from.dist() <= 0 && from.dist() >= 0)) {
    set_dist(from.dist());
  }
}

void ellipseGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.ellipseGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ellipseGate::CopyFrom(const ellipseGate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.ellipseGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ellipseGate::IsInitialized() const {
  return true;
}

void ellipseGate::Swap(ellipseGate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ellipseGate::InternalSwap(ellipseGate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&cov_)->InternalSwap(CastToBase(&other->cov_));
  CastToBase(&antipodal_vertices_)->InternalSwap(CastToBase(&other->antipodal_vertices_));
  swap(mu_, other->mu_);
  swap(dist_, other->dist_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ellipseGate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void BOOL_GATE_OP::InitAsDefaultInstance() {
}
class BOOL_GATE_OP::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BOOL_GATE_OP::kPathFieldNumber;
const int BOOL_GATE_OP::kOpFieldNumber;
const int BOOL_GATE_OP::kIsNotFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BOOL_GATE_OP::BOOL_GATE_OP()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.BOOL_GATE_OP)
}
BOOL_GATE_OP::BOOL_GATE_OP(const BOOL_GATE_OP& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      path_(from.path_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&op_, &from.op_,
    static_cast<size_t>(reinterpret_cast<char*>(&isnot_) -
    reinterpret_cast<char*>(&op_)) + sizeof(isnot_));
  // @@protoc_insertion_point(copy_constructor:pb.BOOL_GATE_OP)
}

void BOOL_GATE_OP::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BOOL_GATE_OP_GatingSet_2eproto.base);
  ::memset(&op_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&isnot_) -
      reinterpret_cast<char*>(&op_)) + sizeof(isnot_));
}

BOOL_GATE_OP::~BOOL_GATE_OP() {
  // @@protoc_insertion_point(destructor:pb.BOOL_GATE_OP)
  SharedDtor();
}

void BOOL_GATE_OP::SharedDtor() {
}

void BOOL_GATE_OP::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const BOOL_GATE_OP& BOOL_GATE_OP::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BOOL_GATE_OP_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void BOOL_GATE_OP::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.BOOL_GATE_OP)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  path_.Clear();
  ::memset(&op_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&isnot_) -
      reinterpret_cast<char*>(&op_)) + sizeof(isnot_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BOOL_GATE_OP::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_path(), ptr, ctx, "pb.BOOL_GATE_OP.path");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      // uint32 op = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          op_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isNot = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          isnot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BOOL_GATE_OP::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.BOOL_GATE_OP)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string path = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->add_path()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->path(this->path_size() - 1).data(),
            static_cast<int>(this->path(this->path_size() - 1).length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.BOOL_GATE_OP.path"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 op = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &op_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isNot = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isnot_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.BOOL_GATE_OP)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.BOOL_GATE_OP)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void BOOL_GATE_OP::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.BOOL_GATE_OP)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string path = 1;
  for (int i = 0, n = this->path_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->path(i).data(), static_cast<int>(this->path(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.BOOL_GATE_OP.path");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
      1, this->path(i), output);
  }

  // uint32 op = 2;
  if (this->op() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->op(), output);
  }

  // bool isNot = 3;
  if (this->isnot() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->isnot(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.BOOL_GATE_OP)
}

::PROTOBUF_NAMESPACE_ID::uint8* BOOL_GATE_OP::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.BOOL_GATE_OP)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string path = 1;
  for (int i = 0, n = this->path_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->path(i).data(), static_cast<int>(this->path(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.BOOL_GATE_OP.path");
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteStringToArray(1, this->path(i), target);
  }

  // uint32 op = 2;
  if (this->op() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->op(), target);
  }

  // bool isNot = 3;
  if (this->isnot() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->isnot(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.BOOL_GATE_OP)
  return target;
}

size_t BOOL_GATE_OP::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.BOOL_GATE_OP)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string path = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->path_size());
  for (int i = 0, n = this->path_size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      this->path(i));
  }

  // uint32 op = 2;
  if (this->op() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->op());
  }

  // bool isNot = 3;
  if (this->isnot() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BOOL_GATE_OP::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.BOOL_GATE_OP)
  GOOGLE_DCHECK_NE(&from, this);
  const BOOL_GATE_OP* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BOOL_GATE_OP>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.BOOL_GATE_OP)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.BOOL_GATE_OP)
    MergeFrom(*source);
  }
}

void BOOL_GATE_OP::MergeFrom(const BOOL_GATE_OP& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.BOOL_GATE_OP)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  path_.MergeFrom(from.path_);
  if (from.op() != 0) {
    set_op(from.op());
  }
  if (from.isnot() != 0) {
    set_isnot(from.isnot());
  }
}

void BOOL_GATE_OP::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.BOOL_GATE_OP)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BOOL_GATE_OP::CopyFrom(const BOOL_GATE_OP& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.BOOL_GATE_OP)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BOOL_GATE_OP::IsInitialized() const {
  return true;
}

void BOOL_GATE_OP::Swap(BOOL_GATE_OP* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BOOL_GATE_OP::InternalSwap(BOOL_GATE_OP* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  path_.InternalSwap(CastToBase(&other->path_));
  swap(op_, other->op_);
  swap(isnot_, other->isnot_);
}

::PROTOBUF_NAMESPACE_ID::Metadata BOOL_GATE_OP::GetMetadata() const {
  return GetMetadataStatic();
}


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

void boolGate::InitAsDefaultInstance() {
}
class boolGate::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int boolGate::kBoolOpSpecFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

boolGate::boolGate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.boolGate)
}
boolGate::boolGate(const boolGate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      boolopspec_(from.boolopspec_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:pb.boolGate)
}

void boolGate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_boolGate_GatingSet_2eproto.base);
}

boolGate::~boolGate() {
  // @@protoc_insertion_point(destructor:pb.boolGate)
  SharedDtor();
}

void boolGate::SharedDtor() {
}

void boolGate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const boolGate& boolGate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_boolGate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void boolGate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.boolGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  boolopspec_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* boolGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_boolopspec(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool boolGate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.boolGate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_boolopspec()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.boolGate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.boolGate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void boolGate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.boolGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->boolopspec_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1,
      this->boolopspec(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.boolGate)
}

::PROTOBUF_NAMESPACE_ID::uint8* boolGate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.boolGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->boolopspec_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->boolopspec(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.boolGate)
  return target;
}

size_t boolGate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.boolGate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .pb.BOOL_GATE_OP boolOpSpec = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->boolopspec_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->boolopspec(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void boolGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.boolGate)
  GOOGLE_DCHECK_NE(&from, this);
  const boolGate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<boolGate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.boolGate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.boolGate)
    MergeFrom(*source);
  }
}

void boolGate::MergeFrom(const boolGate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.boolGate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  boolopspec_.MergeFrom(from.boolopspec_);
}

void boolGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.boolGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void boolGate::CopyFrom(const boolGate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.boolGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool boolGate::IsInitialized() const {
  return true;
}

void boolGate::Swap(boolGate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void boolGate::InternalSwap(boolGate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&boolopspec_)->InternalSwap(CastToBase(&other->boolopspec_));
}

::PROTOBUF_NAMESPACE_ID::Metadata boolGate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void clusterGate::InitAsDefaultInstance() {
}
class clusterGate::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int clusterGate::kClusterMethodFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

clusterGate::clusterGate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.clusterGate)
}
clusterGate::clusterGate(const clusterGate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  cluster_method_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.cluster_method().size() > 0) {
    cluster_method_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cluster_method_);
  }
  // @@protoc_insertion_point(copy_constructor:pb.clusterGate)
}

void clusterGate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_clusterGate_GatingSet_2eproto.base);
  cluster_method_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

clusterGate::~clusterGate() {
  // @@protoc_insertion_point(destructor:pb.clusterGate)
  SharedDtor();
}

void clusterGate::SharedDtor() {
  cluster_method_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void clusterGate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const clusterGate& clusterGate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_clusterGate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void clusterGate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.clusterGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cluster_method_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* clusterGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string cluster_method = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_cluster_method(), ptr, ctx, "pb.clusterGate.cluster_method");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool clusterGate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.clusterGate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string cluster_method = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_cluster_method()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->cluster_method().data(), static_cast<int>(this->cluster_method().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.clusterGate.cluster_method"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.clusterGate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.clusterGate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void clusterGate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.clusterGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string cluster_method = 1;
  if (this->cluster_method().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->cluster_method().data(), static_cast<int>(this->cluster_method().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.clusterGate.cluster_method");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->cluster_method(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.clusterGate)
}

::PROTOBUF_NAMESPACE_ID::uint8* clusterGate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.clusterGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string cluster_method = 1;
  if (this->cluster_method().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->cluster_method().data(), static_cast<int>(this->cluster_method().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.clusterGate.cluster_method");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->cluster_method(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.clusterGate)
  return target;
}

size_t clusterGate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.clusterGate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string cluster_method = 1;
  if (this->cluster_method().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->cluster_method());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void clusterGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.clusterGate)
  GOOGLE_DCHECK_NE(&from, this);
  const clusterGate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<clusterGate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.clusterGate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.clusterGate)
    MergeFrom(*source);
  }
}

void clusterGate::MergeFrom(const clusterGate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.clusterGate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.cluster_method().size() > 0) {

    cluster_method_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cluster_method_);
  }
}

void clusterGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.clusterGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void clusterGate::CopyFrom(const clusterGate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.clusterGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool clusterGate::IsInitialized() const {
  return true;
}

void clusterGate::Swap(clusterGate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void clusterGate::InternalSwap(clusterGate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  cluster_method_.Swap(&other->cluster_method_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata clusterGate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void quadGate::InitAsDefaultInstance() {
}
class quadGate::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int quadGate::kUidFieldNumber;
const int quadGate::kQuadrantFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

quadGate::quadGate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.quadGate)
}
quadGate::quadGate(const quadGate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  uid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.uid().size() > 0) {
    uid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.uid_);
  }
  quadrant_ = from.quadrant_;
  // @@protoc_insertion_point(copy_constructor:pb.quadGate)
}

void quadGate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_quadGate_GatingSet_2eproto.base);
  uid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  quadrant_ = 0;
}

quadGate::~quadGate() {
  // @@protoc_insertion_point(destructor:pb.quadGate)
  SharedDtor();
}

void quadGate::SharedDtor() {
  uid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void quadGate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const quadGate& quadGate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_quadGate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void quadGate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.quadGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  uid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  quadrant_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* quadGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string uid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_uid(), ptr, ctx, "pb.quadGate.uid");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.QUADRANT quadrant = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_quadrant(static_cast<::pb::QUADRANT>(val));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool quadGate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.quadGate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string uid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_uid()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->uid().data(), static_cast<int>(this->uid().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.quadGate.uid"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.QUADRANT quadrant = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_quadrant(static_cast< ::pb::QUADRANT >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.quadGate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.quadGate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void quadGate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.quadGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string uid = 1;
  if (this->uid().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->uid().data(), static_cast<int>(this->uid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.quadGate.uid");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->uid(), output);
  }

  // .pb.QUADRANT quadrant = 3;
  if (this->quadrant() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      3, this->quadrant(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.quadGate)
}

::PROTOBUF_NAMESPACE_ID::uint8* quadGate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.quadGate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string uid = 1;
  if (this->uid().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->uid().data(), static_cast<int>(this->uid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.quadGate.uid");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->uid(), target);
  }

  // .pb.QUADRANT quadrant = 3;
  if (this->quadrant() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->quadrant(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.quadGate)
  return target;
}

size_t quadGate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.quadGate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string uid = 1;
  if (this->uid().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->uid());
  }

  // .pb.QUADRANT quadrant = 3;
  if (this->quadrant() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->quadrant());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void quadGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.quadGate)
  GOOGLE_DCHECK_NE(&from, this);
  const quadGate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<quadGate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.quadGate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.quadGate)
    MergeFrom(*source);
  }
}

void quadGate::MergeFrom(const quadGate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.quadGate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.uid().size() > 0) {

    uid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.uid_);
  }
  if (from.quadrant() != 0) {
    set_quadrant(from.quadrant());
  }
}

void quadGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.quadGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void quadGate::CopyFrom(const quadGate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.quadGate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool quadGate::IsInitialized() const {
  return true;
}

void quadGate::Swap(quadGate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void quadGate::InternalSwap(quadGate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  uid_.Swap(&other->uid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(quadrant_, other->quadrant_);
}

::PROTOBUF_NAMESPACE_ID::Metadata quadGate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void gate::InitAsDefaultInstance() {
  ::pb::_gate_default_instance_._instance.get_mutable()->rg_ = const_cast< ::pb::rangeGate*>(
      ::pb::rangeGate::internal_default_instance());
  ::pb::_gate_default_instance_._instance.get_mutable()->pg_ = const_cast< ::pb::polygonGate*>(
      ::pb::polygonGate::internal_default_instance());
  ::pb::_gate_default_instance_._instance.get_mutable()->eg_ = const_cast< ::pb::ellipseGate*>(
      ::pb::ellipseGate::internal_default_instance());
  ::pb::_gate_default_instance_._instance.get_mutable()->bg_ = const_cast< ::pb::boolGate*>(
      ::pb::boolGate::internal_default_instance());
  ::pb::_gate_default_instance_._instance.get_mutable()->cg_ = const_cast< ::pb::clusterGate*>(
      ::pb::clusterGate::internal_default_instance());
}
class gate::HasBitSetters {
 public:
  static const ::pb::rangeGate& rg(const gate* msg);
  static const ::pb::polygonGate& pg(const gate* msg);
  static const ::pb::ellipseGate& eg(const gate* msg);
  static const ::pb::boolGate& bg(const gate* msg);
  static const ::pb::clusterGate& cg(const gate* msg);
};

const ::pb::rangeGate&
gate::HasBitSetters::rg(const gate* msg) {
  return *msg->rg_;
}
const ::pb::polygonGate&
gate::HasBitSetters::pg(const gate* msg) {
  return *msg->pg_;
}
const ::pb::ellipseGate&
gate::HasBitSetters::eg(const gate* msg) {
  return *msg->eg_;
}
const ::pb::boolGate&
gate::HasBitSetters::bg(const gate* msg) {
  return *msg->bg_;
}
const ::pb::clusterGate&
gate::HasBitSetters::cg(const gate* msg) {
  return *msg->cg_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int gate::kNegFieldNumber;
const int gate::kIsTransformedFieldNumber;
const int gate::kIsGainedFieldNumber;
const int gate::kTypeFieldNumber;
const int gate::kRgFieldNumber;
const int gate::kPgFieldNumber;
const int gate::kEgFieldNumber;
const int gate::kBgFieldNumber;
const int gate::kCgFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

gate::gate()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.gate)
}
gate::gate(const gate& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_rg()) {
    rg_ = new ::pb::rangeGate(*from.rg_);
  } else {
    rg_ = nullptr;
  }
  if (from.has_pg()) {
    pg_ = new ::pb::polygonGate(*from.pg_);
  } else {
    pg_ = nullptr;
  }
  if (from.has_eg()) {
    eg_ = new ::pb::ellipseGate(*from.eg_);
  } else {
    eg_ = nullptr;
  }
  if (from.has_bg()) {
    bg_ = new ::pb::boolGate(*from.bg_);
  } else {
    bg_ = nullptr;
  }
  if (from.has_cg()) {
    cg_ = new ::pb::clusterGate(*from.cg_);
  } else {
    cg_ = nullptr;
  }
  ::memcpy(&neg_, &from.neg_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&neg_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:pb.gate)
}

void gate::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_gate_GatingSet_2eproto.base);
  ::memset(&rg_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&rg_)) + sizeof(type_));
}

gate::~gate() {
  // @@protoc_insertion_point(destructor:pb.gate)
  SharedDtor();
}

void gate::SharedDtor() {
  if (this != internal_default_instance()) delete rg_;
  if (this != internal_default_instance()) delete pg_;
  if (this != internal_default_instance()) delete eg_;
  if (this != internal_default_instance()) delete bg_;
  if (this != internal_default_instance()) delete cg_;
}

void gate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const gate& gate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_gate_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void gate::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.gate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && rg_ != nullptr) {
    delete rg_;
  }
  rg_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && pg_ != nullptr) {
    delete pg_;
  }
  pg_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && eg_ != nullptr) {
    delete eg_;
  }
  eg_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && bg_ != nullptr) {
    delete bg_;
  }
  bg_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && cg_ != nullptr) {
    delete cg_;
  }
  cg_ = nullptr;
  ::memset(&neg_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&neg_)) + sizeof(type_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* gate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool neg = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          neg_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isTransformed = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          istransformed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isGained = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          isgained_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.GATE_TYPE type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_type(static_cast<::pb::GATE_TYPE>(val));
        } else goto handle_unusual;
        continue;
      // .pb.rangeGate rg = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_rg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.polygonGate pg = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(mutable_pg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.ellipseGate eg = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(mutable_eg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.boolGate bg = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(mutable_bg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.clusterGate cg = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(mutable_cg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool gate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.gate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // bool neg = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &neg_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isTransformed = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &istransformed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isGained = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isgained_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.GATE_TYPE type = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::pb::GATE_TYPE >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.rangeGate rg = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_rg()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.polygonGate pg = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_pg()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.ellipseGate eg = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_eg()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.boolGate bg = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_bg()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.clusterGate cg = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (74 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_cg()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.gate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.gate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void gate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.gate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool neg = 1;
  if (this->neg() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->neg(), output);
  }

  // bool isTransformed = 2;
  if (this->istransformed() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->istransformed(), output);
  }

  // bool isGained = 3;
  if (this->isgained() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->isgained(), output);
  }

  // .pb.GATE_TYPE type = 4;
  if (this->type() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      4, this->type(), output);
  }

  // .pb.rangeGate rg = 5;
  if (this->has_rg()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, HasBitSetters::rg(this), output);
  }

  // .pb.polygonGate pg = 6;
  if (this->has_pg()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, HasBitSetters::pg(this), output);
  }

  // .pb.ellipseGate eg = 7;
  if (this->has_eg()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, HasBitSetters::eg(this), output);
  }

  // .pb.boolGate bg = 8;
  if (this->has_bg()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, HasBitSetters::bg(this), output);
  }

  // .pb.clusterGate cg = 9;
  if (this->has_cg()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, HasBitSetters::cg(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.gate)
}

::PROTOBUF_NAMESPACE_ID::uint8* gate::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.gate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool neg = 1;
  if (this->neg() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->neg(), target);
  }

  // bool isTransformed = 2;
  if (this->istransformed() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->istransformed(), target);
  }

  // bool isGained = 3;
  if (this->isgained() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->isgained(), target);
  }

  // .pb.GATE_TYPE type = 4;
  if (this->type() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->type(), target);
  }

  // .pb.rangeGate rg = 5;
  if (this->has_rg()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, HasBitSetters::rg(this), target);
  }

  // .pb.polygonGate pg = 6;
  if (this->has_pg()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, HasBitSetters::pg(this), target);
  }

  // .pb.ellipseGate eg = 7;
  if (this->has_eg()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        7, HasBitSetters::eg(this), target);
  }

  // .pb.boolGate bg = 8;
  if (this->has_bg()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, HasBitSetters::bg(this), target);
  }

  // .pb.clusterGate cg = 9;
  if (this->has_cg()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        9, HasBitSetters::cg(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.gate)
  return target;
}

size_t gate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.gate)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .pb.rangeGate rg = 5;
  if (this->has_rg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *rg_);
  }

  // .pb.polygonGate pg = 6;
  if (this->has_pg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *pg_);
  }

  // .pb.ellipseGate eg = 7;
  if (this->has_eg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *eg_);
  }

  // .pb.boolGate bg = 8;
  if (this->has_bg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *bg_);
  }

  // .pb.clusterGate cg = 9;
  if (this->has_cg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *cg_);
  }

  // bool neg = 1;
  if (this->neg() != 0) {
    total_size += 1 + 1;
  }

  // bool isTransformed = 2;
  if (this->istransformed() != 0) {
    total_size += 1 + 1;
  }

  // bool isGained = 3;
  if (this->isgained() != 0) {
    total_size += 1 + 1;
  }

  // .pb.GATE_TYPE type = 4;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void gate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.gate)
  GOOGLE_DCHECK_NE(&from, this);
  const gate* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<gate>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.gate)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.gate)
    MergeFrom(*source);
  }
}

void gate::MergeFrom(const gate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.gate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_rg()) {
    mutable_rg()->::pb::rangeGate::MergeFrom(from.rg());
  }
  if (from.has_pg()) {
    mutable_pg()->::pb::polygonGate::MergeFrom(from.pg());
  }
  if (from.has_eg()) {
    mutable_eg()->::pb::ellipseGate::MergeFrom(from.eg());
  }
  if (from.has_bg()) {
    mutable_bg()->::pb::boolGate::MergeFrom(from.bg());
  }
  if (from.has_cg()) {
    mutable_cg()->::pb::clusterGate::MergeFrom(from.cg());
  }
  if (from.neg() != 0) {
    set_neg(from.neg());
  }
  if (from.istransformed() != 0) {
    set_istransformed(from.istransformed());
  }
  if (from.isgained() != 0) {
    set_isgained(from.isgained());
  }
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void gate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.gate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void gate::CopyFrom(const gate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.gate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool gate::IsInitialized() const {
  return true;
}

void gate::Swap(gate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void gate::InternalSwap(gate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(rg_, other->rg_);
  swap(pg_, other->pg_);
  swap(eg_, other->eg_);
  swap(bg_, other->bg_);
  swap(cg_, other->cg_);
  swap(neg_, other->neg_);
  swap(istransformed_, other->istransformed_);
  swap(isgained_, other->isgained_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata gate::GetMetadata() const {
  return GetMetadataStatic();
}


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

void POPSTATS::InitAsDefaultInstance() {
}
class POPSTATS::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int POPSTATS::kStatTypeFieldNumber;
const int POPSTATS::kStatValFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

POPSTATS::POPSTATS()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.POPSTATS)
}
POPSTATS::POPSTATS(const POPSTATS& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  stattype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.stattype().size() > 0) {
    stattype_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.stattype_);
  }
  statval_ = from.statval_;
  // @@protoc_insertion_point(copy_constructor:pb.POPSTATS)
}

void POPSTATS::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_POPSTATS_GatingSet_2eproto.base);
  stattype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  statval_ = 0;
}

POPSTATS::~POPSTATS() {
  // @@protoc_insertion_point(destructor:pb.POPSTATS)
  SharedDtor();
}

void POPSTATS::SharedDtor() {
  stattype_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void POPSTATS::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const POPSTATS& POPSTATS::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_POPSTATS_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void POPSTATS::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.POPSTATS)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  stattype_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  statval_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* POPSTATS::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string statType = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_stattype(), ptr, ctx, "pb.POPSTATS.statType");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float statVal = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          statval_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool POPSTATS::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.POPSTATS)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string statType = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_stattype()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->stattype().data(), static_cast<int>(this->stattype().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.POPSTATS.statType"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float statVal = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &statval_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.POPSTATS)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.POPSTATS)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void POPSTATS::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.POPSTATS)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string statType = 1;
  if (this->stattype().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->stattype().data(), static_cast<int>(this->stattype().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.POPSTATS.statType");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->stattype(), output);
  }

  // float statVal = 2;
  if (!(this->statval() <= 0 && this->statval() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->statval(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.POPSTATS)
}

::PROTOBUF_NAMESPACE_ID::uint8* POPSTATS::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.POPSTATS)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string statType = 1;
  if (this->stattype().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->stattype().data(), static_cast<int>(this->stattype().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.POPSTATS.statType");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->stattype(), target);
  }

  // float statVal = 2;
  if (!(this->statval() <= 0 && this->statval() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->statval(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.POPSTATS)
  return target;
}

size_t POPSTATS::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.POPSTATS)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string statType = 1;
  if (this->stattype().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->stattype());
  }

  // float statVal = 2;
  if (!(this->statval() <= 0 && this->statval() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void POPSTATS::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.POPSTATS)
  GOOGLE_DCHECK_NE(&from, this);
  const POPSTATS* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<POPSTATS>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.POPSTATS)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.POPSTATS)
    MergeFrom(*source);
  }
}

void POPSTATS::MergeFrom(const POPSTATS& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.POPSTATS)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.stattype().size() > 0) {

    stattype_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.stattype_);
  }
  if (!(from.statval() <= 0 && from.statval() >= 0)) {
    set_statval(from.statval());
  }
}

void POPSTATS::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.POPSTATS)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void POPSTATS::CopyFrom(const POPSTATS& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.POPSTATS)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool POPSTATS::IsInitialized() const {
  return true;
}

void POPSTATS::Swap(POPSTATS* other) {
  if (other == this) return;
  InternalSwap(other);
}
void POPSTATS::InternalSwap(POPSTATS* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  stattype_.Swap(&other->stattype_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(statval_, other->statval_);
}

::PROTOBUF_NAMESPACE_ID::Metadata POPSTATS::GetMetadata() const {
  return GetMetadataStatic();
}


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

void calibrationTable::InitAsDefaultInstance() {
}
class calibrationTable::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int calibrationTable::kXFieldNumber;
const int calibrationTable::kYFieldNumber;
const int calibrationTable::kBFieldNumber;
const int calibrationTable::kCFieldNumber;
const int calibrationTable::kDFieldNumber;
const int calibrationTable::kSplineMethodFieldNumber;
const int calibrationTable::kCaltypeFieldNumber;
const int calibrationTable::kFlagFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

calibrationTable::calibrationTable()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.calibrationTable)
}
calibrationTable::calibrationTable(const calibrationTable& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      x_(from.x_),
      y_(from.y_),
      b_(from.b_),
      c_(from.c_),
      d_(from.d_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  caltype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.caltype().size() > 0) {
    caltype_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.caltype_);
  }
  ::memcpy(&spline_method_, &from.spline_method_,
    static_cast<size_t>(reinterpret_cast<char*>(&flag_) -
    reinterpret_cast<char*>(&spline_method_)) + sizeof(flag_));
  // @@protoc_insertion_point(copy_constructor:pb.calibrationTable)
}

void calibrationTable::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_calibrationTable_GatingSet_2eproto.base);
  caltype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&spline_method_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&flag_) -
      reinterpret_cast<char*>(&spline_method_)) + sizeof(flag_));
}

calibrationTable::~calibrationTable() {
  // @@protoc_insertion_point(destructor:pb.calibrationTable)
  SharedDtor();
}

void calibrationTable::SharedDtor() {
  caltype_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void calibrationTable::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const calibrationTable& calibrationTable::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_calibrationTable_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void calibrationTable::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.calibrationTable)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  x_.Clear();
  y_.Clear();
  b_.Clear();
  c_.Clear();
  d_.Clear();
  caltype_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&spline_method_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&flag_) -
      reinterpret_cast<char*>(&spline_method_)) + sizeof(flag_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* calibrationTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated float x = 1 [packed = true];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_x(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13) {
          add_x(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // repeated float y = 2 [packed = true];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_y(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21) {
          add_y(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // repeated float b = 3 [packed = true];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_b(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29) {
          add_b(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // repeated float c = 4 [packed = true];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_c(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) {
          add_c(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // repeated float d = 5 [packed = true];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_d(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45) {
          add_d(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // uint32 spline_method = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          spline_method_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string caltype = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_caltype(), ptr, ctx, "pb.calibrationTable.caltype");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool flag = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          flag_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool calibrationTable::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.calibrationTable)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated float x = 1 [packed = true];
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_x())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 10u, input, this->mutable_x())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float y = 2 [packed = true];
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_y())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 18u, input, this->mutable_y())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float b = 3 [packed = true];
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_b())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 26u, input, this->mutable_b())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float c = 4 [packed = true];
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_c())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 34u, input, this->mutable_c())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float d = 5 [packed = true];
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_d())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 42u, input, this->mutable_d())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 spline_method = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &spline_method_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string caltype = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_caltype()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->caltype().data(), static_cast<int>(this->caltype().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.calibrationTable.caltype"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool flag = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &flag_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.calibrationTable)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.calibrationTable)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void calibrationTable::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.calibrationTable)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated float x = 1 [packed = true];
  if (this->x_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_x_cached_byte_size_.load(
        std::memory_order_relaxed));
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
      this->x().data(), this->x_size(), output);
  }

  // repeated float y = 2 [packed = true];
  if (this->y_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_y_cached_byte_size_.load(
        std::memory_order_relaxed));
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
      this->y().data(), this->y_size(), output);
  }

  // repeated float b = 3 [packed = true];
  if (this->b_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_b_cached_byte_size_.load(
        std::memory_order_relaxed));
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
      this->b().data(), this->b_size(), output);
  }

  // repeated float c = 4 [packed = true];
  if (this->c_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_c_cached_byte_size_.load(
        std::memory_order_relaxed));
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
      this->c().data(), this->c_size(), output);
  }

  // repeated float d = 5 [packed = true];
  if (this->d_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(5, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_d_cached_byte_size_.load(
        std::memory_order_relaxed));
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
      this->d().data(), this->d_size(), output);
  }

  // uint32 spline_method = 6;
  if (this->spline_method() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(6, this->spline_method(), output);
  }

  // string caltype = 7;
  if (this->caltype().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->caltype().data(), static_cast<int>(this->caltype().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.calibrationTable.caltype");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      7, this->caltype(), output);
  }

  // bool flag = 8;
  if (this->flag() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(8, this->flag(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.calibrationTable)
}

::PROTOBUF_NAMESPACE_ID::uint8* calibrationTable::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.calibrationTable)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated float x = 1 [packed = true];
  if (this->x_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      1,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _x_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->x_, target);
  }

  // repeated float y = 2 [packed = true];
  if (this->y_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      2,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _y_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->y_, target);
  }

  // repeated float b = 3 [packed = true];
  if (this->b_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      3,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _b_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->b_, target);
  }

  // repeated float c = 4 [packed = true];
  if (this->c_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      4,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _c_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->c_, target);
  }

  // repeated float d = 5 [packed = true];
  if (this->d_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      5,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _d_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->d_, target);
  }

  // uint32 spline_method = 6;
  if (this->spline_method() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->spline_method(), target);
  }

  // string caltype = 7;
  if (this->caltype().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->caltype().data(), static_cast<int>(this->caltype().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.calibrationTable.caltype");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        7, this->caltype(), target);
  }

  // bool flag = 8;
  if (this->flag() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->flag(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.calibrationTable)
  return target;
}

size_t calibrationTable::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.calibrationTable)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated float x = 1 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->x_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _x_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated float y = 2 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->y_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _y_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated float b = 3 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->b_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _b_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated float c = 4 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->c_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _c_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated float d = 5 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->d_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _d_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // string caltype = 7;
  if (this->caltype().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->caltype());
  }

  // uint32 spline_method = 6;
  if (this->spline_method() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->spline_method());
  }

  // bool flag = 8;
  if (this->flag() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void calibrationTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.calibrationTable)
  GOOGLE_DCHECK_NE(&from, this);
  const calibrationTable* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<calibrationTable>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.calibrationTable)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.calibrationTable)
    MergeFrom(*source);
  }
}

void calibrationTable::MergeFrom(const calibrationTable& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.calibrationTable)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  x_.MergeFrom(from.x_);
  y_.MergeFrom(from.y_);
  b_.MergeFrom(from.b_);
  c_.MergeFrom(from.c_);
  d_.MergeFrom(from.d_);
  if (from.caltype().size() > 0) {

    caltype_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.caltype_);
  }
  if (from.spline_method() != 0) {
    set_spline_method(from.spline_method());
  }
  if (from.flag() != 0) {
    set_flag(from.flag());
  }
}

void calibrationTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.calibrationTable)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void calibrationTable::CopyFrom(const calibrationTable& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.calibrationTable)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool calibrationTable::IsInitialized() const {
  return true;
}

void calibrationTable::Swap(calibrationTable* other) {
  if (other == this) return;
  InternalSwap(other);
}
void calibrationTable::InternalSwap(calibrationTable* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  x_.InternalSwap(&other->x_);
  y_.InternalSwap(&other->y_);
  b_.InternalSwap(&other->b_);
  c_.InternalSwap(&other->c_);
  d_.InternalSwap(&other->d_);
  caltype_.Swap(&other->caltype_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(spline_method_, other->spline_method_);
  swap(flag_, other->flag_);
}

::PROTOBUF_NAMESPACE_ID::Metadata calibrationTable::GetMetadata() const {
  return GetMetadataStatic();
}


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

void biexpTrans::InitAsDefaultInstance() {
}
class biexpTrans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int biexpTrans::kChannelRangeFieldNumber;
const int biexpTrans::kPosFieldNumber;
const int biexpTrans::kNegFieldNumber;
const int biexpTrans::kWidthBasisFieldNumber;
const int biexpTrans::kMaxValueFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

biexpTrans::biexpTrans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.biexpTrans)
}
biexpTrans::biexpTrans(const biexpTrans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&channelrange_, &from.channelrange_,
    static_cast<size_t>(reinterpret_cast<char*>(&maxvalue_) -
    reinterpret_cast<char*>(&channelrange_)) + sizeof(maxvalue_));
  // @@protoc_insertion_point(copy_constructor:pb.biexpTrans)
}

void biexpTrans::SharedCtor() {
  ::memset(&channelrange_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&maxvalue_) -
      reinterpret_cast<char*>(&channelrange_)) + sizeof(maxvalue_));
}

biexpTrans::~biexpTrans() {
  // @@protoc_insertion_point(destructor:pb.biexpTrans)
  SharedDtor();
}

void biexpTrans::SharedDtor() {
}

void biexpTrans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const biexpTrans& biexpTrans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_biexpTrans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void biexpTrans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.biexpTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&channelrange_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&maxvalue_) -
      reinterpret_cast<char*>(&channelrange_)) + sizeof(maxvalue_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* biexpTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // uint32 channelRange = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          channelrange_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // float pos = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          pos_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float neg = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          neg_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float widthBasis = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          widthbasis_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float maxValue = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          maxvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool biexpTrans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.biexpTrans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // uint32 channelRange = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &channelrange_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float pos = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &pos_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float neg = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &neg_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float widthBasis = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &widthbasis_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float maxValue = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &maxvalue_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.biexpTrans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.biexpTrans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void biexpTrans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.biexpTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 channelRange = 1;
  if (this->channelrange() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->channelrange(), output);
  }

  // float pos = 2;
  if (!(this->pos() <= 0 && this->pos() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->pos(), output);
  }

  // float neg = 3;
  if (!(this->neg() <= 0 && this->neg() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->neg(), output);
  }

  // float widthBasis = 4;
  if (!(this->widthbasis() <= 0 && this->widthbasis() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->widthbasis(), output);
  }

  // float maxValue = 5;
  if (!(this->maxvalue() <= 0 && this->maxvalue() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(5, this->maxvalue(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.biexpTrans)
}

::PROTOBUF_NAMESPACE_ID::uint8* biexpTrans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.biexpTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 channelRange = 1;
  if (this->channelrange() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->channelrange(), target);
  }

  // float pos = 2;
  if (!(this->pos() <= 0 && this->pos() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->pos(), target);
  }

  // float neg = 3;
  if (!(this->neg() <= 0 && this->neg() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->neg(), target);
  }

  // float widthBasis = 4;
  if (!(this->widthbasis() <= 0 && this->widthbasis() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->widthbasis(), target);
  }

  // float maxValue = 5;
  if (!(this->maxvalue() <= 0 && this->maxvalue() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->maxvalue(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.biexpTrans)
  return target;
}

size_t biexpTrans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.biexpTrans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // uint32 channelRange = 1;
  if (this->channelrange() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->channelrange());
  }

  // float pos = 2;
  if (!(this->pos() <= 0 && this->pos() >= 0)) {
    total_size += 1 + 4;
  }

  // float neg = 3;
  if (!(this->neg() <= 0 && this->neg() >= 0)) {
    total_size += 1 + 4;
  }

  // float widthBasis = 4;
  if (!(this->widthbasis() <= 0 && this->widthbasis() >= 0)) {
    total_size += 1 + 4;
  }

  // float maxValue = 5;
  if (!(this->maxvalue() <= 0 && this->maxvalue() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void biexpTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.biexpTrans)
  GOOGLE_DCHECK_NE(&from, this);
  const biexpTrans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<biexpTrans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.biexpTrans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.biexpTrans)
    MergeFrom(*source);
  }
}

void biexpTrans::MergeFrom(const biexpTrans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.biexpTrans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.channelrange() != 0) {
    set_channelrange(from.channelrange());
  }
  if (!(from.pos() <= 0 && from.pos() >= 0)) {
    set_pos(from.pos());
  }
  if (!(from.neg() <= 0 && from.neg() >= 0)) {
    set_neg(from.neg());
  }
  if (!(from.widthbasis() <= 0 && from.widthbasis() >= 0)) {
    set_widthbasis(from.widthbasis());
  }
  if (!(from.maxvalue() <= 0 && from.maxvalue() >= 0)) {
    set_maxvalue(from.maxvalue());
  }
}

void biexpTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.biexpTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void biexpTrans::CopyFrom(const biexpTrans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.biexpTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool biexpTrans::IsInitialized() const {
  return true;
}

void biexpTrans::Swap(biexpTrans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void biexpTrans::InternalSwap(biexpTrans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(channelrange_, other->channelrange_);
  swap(pos_, other->pos_);
  swap(neg_, other->neg_);
  swap(widthbasis_, other->widthbasis_);
  swap(maxvalue_, other->maxvalue_);
}

::PROTOBUF_NAMESPACE_ID::Metadata biexpTrans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void fasinhTrans::InitAsDefaultInstance() {
}
class fasinhTrans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int fasinhTrans::kLengthFieldNumber;
const int fasinhTrans::kMaxRangeFieldNumber;
const int fasinhTrans::kTFieldNumber;
const int fasinhTrans::kAFieldNumber;
const int fasinhTrans::kMFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

fasinhTrans::fasinhTrans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.fasinhTrans)
}
fasinhTrans::fasinhTrans(const fasinhTrans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&length_, &from.length_,
    static_cast<size_t>(reinterpret_cast<char*>(&m_) -
    reinterpret_cast<char*>(&length_)) + sizeof(m_));
  // @@protoc_insertion_point(copy_constructor:pb.fasinhTrans)
}

void fasinhTrans::SharedCtor() {
  ::memset(&length_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&m_) -
      reinterpret_cast<char*>(&length_)) + sizeof(m_));
}

fasinhTrans::~fasinhTrans() {
  // @@protoc_insertion_point(destructor:pb.fasinhTrans)
  SharedDtor();
}

void fasinhTrans::SharedDtor() {
}

void fasinhTrans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const fasinhTrans& fasinhTrans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_fasinhTrans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void fasinhTrans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.fasinhTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&length_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&m_) -
      reinterpret_cast<char*>(&length_)) + sizeof(m_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* fasinhTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float length = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          length_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float maxRange = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          maxrange_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float T = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float A = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          a_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float M = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          m_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool fasinhTrans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.fasinhTrans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float length = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &length_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float maxRange = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &maxrange_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float T = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &t_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float A = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &a_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float M = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &m_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.fasinhTrans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.fasinhTrans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void fasinhTrans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.fasinhTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float length = 1;
  if (!(this->length() <= 0 && this->length() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->length(), output);
  }

  // float maxRange = 2;
  if (!(this->maxrange() <= 0 && this->maxrange() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->maxrange(), output);
  }

  // float T = 3;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->t(), output);
  }

  // float A = 4;
  if (!(this->a() <= 0 && this->a() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->a(), output);
  }

  // float M = 5;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(5, this->m(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.fasinhTrans)
}

::PROTOBUF_NAMESPACE_ID::uint8* fasinhTrans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.fasinhTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float length = 1;
  if (!(this->length() <= 0 && this->length() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->length(), target);
  }

  // float maxRange = 2;
  if (!(this->maxrange() <= 0 && this->maxrange() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->maxrange(), target);
  }

  // float T = 3;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->t(), target);
  }

  // float A = 4;
  if (!(this->a() <= 0 && this->a() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->a(), target);
  }

  // float M = 5;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->m(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.fasinhTrans)
  return target;
}

size_t fasinhTrans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.fasinhTrans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float length = 1;
  if (!(this->length() <= 0 && this->length() >= 0)) {
    total_size += 1 + 4;
  }

  // float maxRange = 2;
  if (!(this->maxrange() <= 0 && this->maxrange() >= 0)) {
    total_size += 1 + 4;
  }

  // float T = 3;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    total_size += 1 + 4;
  }

  // float A = 4;
  if (!(this->a() <= 0 && this->a() >= 0)) {
    total_size += 1 + 4;
  }

  // float M = 5;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void fasinhTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.fasinhTrans)
  GOOGLE_DCHECK_NE(&from, this);
  const fasinhTrans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<fasinhTrans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.fasinhTrans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.fasinhTrans)
    MergeFrom(*source);
  }
}

void fasinhTrans::MergeFrom(const fasinhTrans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.fasinhTrans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.length() <= 0 && from.length() >= 0)) {
    set_length(from.length());
  }
  if (!(from.maxrange() <= 0 && from.maxrange() >= 0)) {
    set_maxrange(from.maxrange());
  }
  if (!(from.t() <= 0 && from.t() >= 0)) {
    set_t(from.t());
  }
  if (!(from.a() <= 0 && from.a() >= 0)) {
    set_a(from.a());
  }
  if (!(from.m() <= 0 && from.m() >= 0)) {
    set_m(from.m());
  }
}

void fasinhTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.fasinhTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void fasinhTrans::CopyFrom(const fasinhTrans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.fasinhTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool fasinhTrans::IsInitialized() const {
  return true;
}

void fasinhTrans::Swap(fasinhTrans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void fasinhTrans::InternalSwap(fasinhTrans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(length_, other->length_);
  swap(maxrange_, other->maxrange_);
  swap(t_, other->t_);
  swap(a_, other->a_);
  swap(m_, other->m_);
}

::PROTOBUF_NAMESPACE_ID::Metadata fasinhTrans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void scaleTrans::InitAsDefaultInstance() {
}
class scaleTrans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int scaleTrans::kScaleFactorFieldNumber;
const int scaleTrans::kTScaleFieldNumber;
const int scaleTrans::kRScaleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

scaleTrans::scaleTrans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.scaleTrans)
}
scaleTrans::scaleTrans(const scaleTrans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&scale_factor_, &from.scale_factor_,
    static_cast<size_t>(reinterpret_cast<char*>(&r_scale_) -
    reinterpret_cast<char*>(&scale_factor_)) + sizeof(r_scale_));
  // @@protoc_insertion_point(copy_constructor:pb.scaleTrans)
}

void scaleTrans::SharedCtor() {
  ::memset(&scale_factor_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&r_scale_) -
      reinterpret_cast<char*>(&scale_factor_)) + sizeof(r_scale_));
}

scaleTrans::~scaleTrans() {
  // @@protoc_insertion_point(destructor:pb.scaleTrans)
  SharedDtor();
}

void scaleTrans::SharedDtor() {
}

void scaleTrans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const scaleTrans& scaleTrans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_scaleTrans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void scaleTrans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.scaleTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&scale_factor_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&r_scale_) -
      reinterpret_cast<char*>(&scale_factor_)) + sizeof(r_scale_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* scaleTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float scale_factor = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          scale_factor_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float t_scale = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          t_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float r_scale = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          r_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool scaleTrans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.scaleTrans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float scale_factor = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_factor_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float t_scale = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &t_scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float r_scale = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &r_scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.scaleTrans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.scaleTrans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void scaleTrans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.scaleTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float scale_factor = 1;
  if (!(this->scale_factor() <= 0 && this->scale_factor() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->scale_factor(), output);
  }

  // float t_scale = 2;
  if (!(this->t_scale() <= 0 && this->t_scale() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->t_scale(), output);
  }

  // float r_scale = 3;
  if (!(this->r_scale() <= 0 && this->r_scale() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->r_scale(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.scaleTrans)
}

::PROTOBUF_NAMESPACE_ID::uint8* scaleTrans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.scaleTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float scale_factor = 1;
  if (!(this->scale_factor() <= 0 && this->scale_factor() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->scale_factor(), target);
  }

  // float t_scale = 2;
  if (!(this->t_scale() <= 0 && this->t_scale() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->t_scale(), target);
  }

  // float r_scale = 3;
  if (!(this->r_scale() <= 0 && this->r_scale() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->r_scale(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.scaleTrans)
  return target;
}

size_t scaleTrans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.scaleTrans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float scale_factor = 1;
  if (!(this->scale_factor() <= 0 && this->scale_factor() >= 0)) {
    total_size += 1 + 4;
  }

  // float t_scale = 2;
  if (!(this->t_scale() <= 0 && this->t_scale() >= 0)) {
    total_size += 1 + 4;
  }

  // float r_scale = 3;
  if (!(this->r_scale() <= 0 && this->r_scale() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void scaleTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.scaleTrans)
  GOOGLE_DCHECK_NE(&from, this);
  const scaleTrans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<scaleTrans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.scaleTrans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.scaleTrans)
    MergeFrom(*source);
  }
}

void scaleTrans::MergeFrom(const scaleTrans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.scaleTrans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.scale_factor() <= 0 && from.scale_factor() >= 0)) {
    set_scale_factor(from.scale_factor());
  }
  if (!(from.t_scale() <= 0 && from.t_scale() >= 0)) {
    set_t_scale(from.t_scale());
  }
  if (!(from.r_scale() <= 0 && from.r_scale() >= 0)) {
    set_r_scale(from.r_scale());
  }
}

void scaleTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.scaleTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void scaleTrans::CopyFrom(const scaleTrans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.scaleTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool scaleTrans::IsInitialized() const {
  return true;
}

void scaleTrans::Swap(scaleTrans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void scaleTrans::InternalSwap(scaleTrans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(scale_factor_, other->scale_factor_);
  swap(t_scale_, other->t_scale_);
  swap(r_scale_, other->r_scale_);
}

::PROTOBUF_NAMESPACE_ID::Metadata scaleTrans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void flinTrans::InitAsDefaultInstance() {
}
class flinTrans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int flinTrans::kMinFieldNumber;
const int flinTrans::kMaxFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

flinTrans::flinTrans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.flinTrans)
}
flinTrans::flinTrans(const flinTrans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&min_, &from.min_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_) -
    reinterpret_cast<char*>(&min_)) + sizeof(max_));
  // @@protoc_insertion_point(copy_constructor:pb.flinTrans)
}

void flinTrans::SharedCtor() {
  ::memset(&min_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_) -
      reinterpret_cast<char*>(&min_)) + sizeof(max_));
}

flinTrans::~flinTrans() {
  // @@protoc_insertion_point(destructor:pb.flinTrans)
  SharedDtor();
}

void flinTrans::SharedDtor() {
}

void flinTrans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const flinTrans& flinTrans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_flinTrans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void flinTrans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.flinTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&min_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_) -
      reinterpret_cast<char*>(&min_)) + sizeof(max_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* flinTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float min = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float max = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool flinTrans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.flinTrans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float min = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &min_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float max = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &max_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.flinTrans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.flinTrans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void flinTrans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.flinTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float min = 1;
  if (!(this->min() <= 0 && this->min() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->min(), output);
  }

  // float max = 2;
  if (!(this->max() <= 0 && this->max() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->max(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.flinTrans)
}

::PROTOBUF_NAMESPACE_ID::uint8* flinTrans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.flinTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float min = 1;
  if (!(this->min() <= 0 && this->min() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->min(), target);
  }

  // float max = 2;
  if (!(this->max() <= 0 && this->max() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->max(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.flinTrans)
  return target;
}

size_t flinTrans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.flinTrans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float min = 1;
  if (!(this->min() <= 0 && this->min() >= 0)) {
    total_size += 1 + 4;
  }

  // float max = 2;
  if (!(this->max() <= 0 && this->max() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void flinTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.flinTrans)
  GOOGLE_DCHECK_NE(&from, this);
  const flinTrans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<flinTrans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.flinTrans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.flinTrans)
    MergeFrom(*source);
  }
}

void flinTrans::MergeFrom(const flinTrans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.flinTrans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.min() <= 0 && from.min() >= 0)) {
    set_min(from.min());
  }
  if (!(from.max() <= 0 && from.max() >= 0)) {
    set_max(from.max());
  }
}

void flinTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.flinTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void flinTrans::CopyFrom(const flinTrans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.flinTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool flinTrans::IsInitialized() const {
  return true;
}

void flinTrans::Swap(flinTrans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void flinTrans::InternalSwap(flinTrans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(min_, other->min_);
  swap(max_, other->max_);
}

::PROTOBUF_NAMESPACE_ID::Metadata flinTrans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void logTrans::InitAsDefaultInstance() {
}
class logTrans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int logTrans::kOffsetFieldNumber;
const int logTrans::kDecadeFieldNumber;
const int logTrans::kTFieldNumber;
const int logTrans::kScaleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

logTrans::logTrans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.logTrans)
}
logTrans::logTrans(const logTrans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&offset_, &from.offset_,
    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
    reinterpret_cast<char*>(&offset_)) + sizeof(scale_));
  // @@protoc_insertion_point(copy_constructor:pb.logTrans)
}

void logTrans::SharedCtor() {
  ::memset(&offset_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&scale_) -
      reinterpret_cast<char*>(&offset_)) + sizeof(scale_));
}

logTrans::~logTrans() {
  // @@protoc_insertion_point(destructor:pb.logTrans)
  SharedDtor();
}

void logTrans::SharedDtor() {
}

void logTrans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const logTrans& logTrans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_logTrans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void logTrans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.logTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&offset_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&scale_) -
      reinterpret_cast<char*>(&offset_)) + sizeof(scale_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* logTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float offset = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float decade = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          decade_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float T = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float scale = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool logTrans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.logTrans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float offset = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float decade = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &decade_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float T = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &t_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float scale = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &scale_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.logTrans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.logTrans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void logTrans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.logTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float offset = 1;
  if (!(this->offset() <= 0 && this->offset() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->offset(), output);
  }

  // float decade = 2;
  if (!(this->decade() <= 0 && this->decade() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->decade(), output);
  }

  // float T = 3;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->t(), output);
  }

  // float scale = 4;
  if (!(this->scale() <= 0 && this->scale() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->scale(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.logTrans)
}

::PROTOBUF_NAMESPACE_ID::uint8* logTrans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.logTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float offset = 1;
  if (!(this->offset() <= 0 && this->offset() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->offset(), target);
  }

  // float decade = 2;
  if (!(this->decade() <= 0 && this->decade() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->decade(), target);
  }

  // float T = 3;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->t(), target);
  }

  // float scale = 4;
  if (!(this->scale() <= 0 && this->scale() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->scale(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.logTrans)
  return target;
}

size_t logTrans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.logTrans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float offset = 1;
  if (!(this->offset() <= 0 && this->offset() >= 0)) {
    total_size += 1 + 4;
  }

  // float decade = 2;
  if (!(this->decade() <= 0 && this->decade() >= 0)) {
    total_size += 1 + 4;
  }

  // float T = 3;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    total_size += 1 + 4;
  }

  // float scale = 4;
  if (!(this->scale() <= 0 && this->scale() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void logTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.logTrans)
  GOOGLE_DCHECK_NE(&from, this);
  const logTrans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<logTrans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.logTrans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.logTrans)
    MergeFrom(*source);
  }
}

void logTrans::MergeFrom(const logTrans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.logTrans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.offset() <= 0 && from.offset() >= 0)) {
    set_offset(from.offset());
  }
  if (!(from.decade() <= 0 && from.decade() >= 0)) {
    set_decade(from.decade());
  }
  if (!(from.t() <= 0 && from.t() >= 0)) {
    set_t(from.t());
  }
  if (!(from.scale() <= 0 && from.scale() >= 0)) {
    set_scale(from.scale());
  }
}

void logTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.logTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void logTrans::CopyFrom(const logTrans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.logTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool logTrans::IsInitialized() const {
  return true;
}

void logTrans::Swap(logTrans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void logTrans::InternalSwap(logTrans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(offset_, other->offset_);
  swap(decade_, other->decade_);
  swap(t_, other->t_);
  swap(scale_, other->scale_);
}

::PROTOBUF_NAMESPACE_ID::Metadata logTrans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void logGML2Trans::InitAsDefaultInstance() {
}
class logGML2Trans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int logGML2Trans::kTFieldNumber;
const int logGML2Trans::kMFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

logGML2Trans::logGML2Trans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.logGML2Trans)
}
logGML2Trans::logGML2Trans(const logGML2Trans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&t_, &from.t_,
    static_cast<size_t>(reinterpret_cast<char*>(&m_) -
    reinterpret_cast<char*>(&t_)) + sizeof(m_));
  // @@protoc_insertion_point(copy_constructor:pb.logGML2Trans)
}

void logGML2Trans::SharedCtor() {
  ::memset(&t_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&m_) -
      reinterpret_cast<char*>(&t_)) + sizeof(m_));
}

logGML2Trans::~logGML2Trans() {
  // @@protoc_insertion_point(destructor:pb.logGML2Trans)
  SharedDtor();
}

void logGML2Trans::SharedDtor() {
}

void logGML2Trans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const logGML2Trans& logGML2Trans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_logGML2Trans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void logGML2Trans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.logGML2Trans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&t_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&m_) -
      reinterpret_cast<char*>(&t_)) + sizeof(m_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* logGML2Trans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float T = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float M = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          m_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool logGML2Trans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.logGML2Trans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float T = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &t_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float M = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &m_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.logGML2Trans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.logGML2Trans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void logGML2Trans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.logGML2Trans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float T = 1;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->t(), output);
  }

  // float M = 2;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->m(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.logGML2Trans)
}

::PROTOBUF_NAMESPACE_ID::uint8* logGML2Trans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.logGML2Trans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float T = 1;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->t(), target);
  }

  // float M = 2;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->m(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.logGML2Trans)
  return target;
}

size_t logGML2Trans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.logGML2Trans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float T = 1;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    total_size += 1 + 4;
  }

  // float M = 2;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    total_size += 1 + 4;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void logGML2Trans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.logGML2Trans)
  GOOGLE_DCHECK_NE(&from, this);
  const logGML2Trans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<logGML2Trans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.logGML2Trans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.logGML2Trans)
    MergeFrom(*source);
  }
}

void logGML2Trans::MergeFrom(const logGML2Trans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.logGML2Trans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.t() <= 0 && from.t() >= 0)) {
    set_t(from.t());
  }
  if (!(from.m() <= 0 && from.m() >= 0)) {
    set_m(from.m());
  }
}

void logGML2Trans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.logGML2Trans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void logGML2Trans::CopyFrom(const logGML2Trans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.logGML2Trans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool logGML2Trans::IsInitialized() const {
  return true;
}

void logGML2Trans::Swap(logGML2Trans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void logGML2Trans::InternalSwap(logGML2Trans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(t_, other->t_);
  swap(m_, other->m_);
}

::PROTOBUF_NAMESPACE_ID::Metadata logGML2Trans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void logicleTrans::InitAsDefaultInstance() {
}
class logicleTrans::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int logicleTrans::kTFieldNumber;
const int logicleTrans::kWFieldNumber;
const int logicleTrans::kMFieldNumber;
const int logicleTrans::kAFieldNumber;
const int logicleTrans::kBinsFieldNumber;
const int logicleTrans::kIsGml2FieldNumber;
const int logicleTrans::kIsInverseFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

logicleTrans::logicleTrans()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.logicleTrans)
}
logicleTrans::logicleTrans(const logicleTrans& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&t_, &from.t_,
    static_cast<size_t>(reinterpret_cast<char*>(&isinverse_) -
    reinterpret_cast<char*>(&t_)) + sizeof(isinverse_));
  // @@protoc_insertion_point(copy_constructor:pb.logicleTrans)
}

void logicleTrans::SharedCtor() {
  ::memset(&t_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&isinverse_) -
      reinterpret_cast<char*>(&t_)) + sizeof(isinverse_));
}

logicleTrans::~logicleTrans() {
  // @@protoc_insertion_point(destructor:pb.logicleTrans)
  SharedDtor();
}

void logicleTrans::SharedDtor() {
}

void logicleTrans::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const logicleTrans& logicleTrans::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_logicleTrans_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void logicleTrans::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.logicleTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&t_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&isinverse_) -
      reinterpret_cast<char*>(&t_)) + sizeof(isinverse_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* logicleTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // float T = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float W = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          w_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float M = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          m_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float A = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          a_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // float bins = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          bins_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // bool isGml2 = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          isgml2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isInverse = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          isinverse_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool logicleTrans::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.logicleTrans)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // float T = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &t_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float W = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &w_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float M = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &m_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float A = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &a_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // float bins = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &bins_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isGml2 = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isgml2_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isInverse = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isinverse_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.logicleTrans)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.logicleTrans)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void logicleTrans::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.logicleTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float T = 1;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(1, this->t(), output);
  }

  // float W = 2;
  if (!(this->w() <= 0 && this->w() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->w(), output);
  }

  // float M = 3;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->m(), output);
  }

  // float A = 4;
  if (!(this->a() <= 0 && this->a() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->a(), output);
  }

  // float bins = 5;
  if (!(this->bins() <= 0 && this->bins() >= 0)) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(5, this->bins(), output);
  }

  // bool isGml2 = 6;
  if (this->isgml2() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->isgml2(), output);
  }

  // bool isInverse = 7;
  if (this->isinverse() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(7, this->isinverse(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.logicleTrans)
}

::PROTOBUF_NAMESPACE_ID::uint8* logicleTrans::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.logicleTrans)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // float T = 1;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->t(), target);
  }

  // float W = 2;
  if (!(this->w() <= 0 && this->w() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->w(), target);
  }

  // float M = 3;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->m(), target);
  }

  // float A = 4;
  if (!(this->a() <= 0 && this->a() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->a(), target);
  }

  // float bins = 5;
  if (!(this->bins() <= 0 && this->bins() >= 0)) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->bins(), target);
  }

  // bool isGml2 = 6;
  if (this->isgml2() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->isgml2(), target);
  }

  // bool isInverse = 7;
  if (this->isinverse() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->isinverse(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.logicleTrans)
  return target;
}

size_t logicleTrans::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.logicleTrans)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // float T = 1;
  if (!(this->t() <= 0 && this->t() >= 0)) {
    total_size += 1 + 4;
  }

  // float W = 2;
  if (!(this->w() <= 0 && this->w() >= 0)) {
    total_size += 1 + 4;
  }

  // float M = 3;
  if (!(this->m() <= 0 && this->m() >= 0)) {
    total_size += 1 + 4;
  }

  // float A = 4;
  if (!(this->a() <= 0 && this->a() >= 0)) {
    total_size += 1 + 4;
  }

  // float bins = 5;
  if (!(this->bins() <= 0 && this->bins() >= 0)) {
    total_size += 1 + 4;
  }

  // bool isGml2 = 6;
  if (this->isgml2() != 0) {
    total_size += 1 + 1;
  }

  // bool isInverse = 7;
  if (this->isinverse() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void logicleTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.logicleTrans)
  GOOGLE_DCHECK_NE(&from, this);
  const logicleTrans* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<logicleTrans>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.logicleTrans)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.logicleTrans)
    MergeFrom(*source);
  }
}

void logicleTrans::MergeFrom(const logicleTrans& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.logicleTrans)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (!(from.t() <= 0 && from.t() >= 0)) {
    set_t(from.t());
  }
  if (!(from.w() <= 0 && from.w() >= 0)) {
    set_w(from.w());
  }
  if (!(from.m() <= 0 && from.m() >= 0)) {
    set_m(from.m());
  }
  if (!(from.a() <= 0 && from.a() >= 0)) {
    set_a(from.a());
  }
  if (!(from.bins() <= 0 && from.bins() >= 0)) {
    set_bins(from.bins());
  }
  if (from.isgml2() != 0) {
    set_isgml2(from.isgml2());
  }
  if (from.isinverse() != 0) {
    set_isinverse(from.isinverse());
  }
}

void logicleTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.logicleTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void logicleTrans::CopyFrom(const logicleTrans& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.logicleTrans)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool logicleTrans::IsInitialized() const {
  return true;
}

void logicleTrans::Swap(logicleTrans* other) {
  if (other == this) return;
  InternalSwap(other);
}
void logicleTrans::InternalSwap(logicleTrans* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(t_, other->t_);
  swap(w_, other->w_);
  swap(m_, other->m_);
  swap(a_, other->a_);
  swap(bins_, other->bins_);
  swap(isgml2_, other->isgml2_);
  swap(isinverse_, other->isinverse_);
}

::PROTOBUF_NAMESPACE_ID::Metadata logicleTrans::GetMetadata() const {
  return GetMetadataStatic();
}


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

void transformation::InitAsDefaultInstance() {
  ::pb::_transformation_default_instance_._instance.get_mutable()->caltbl_ = const_cast< ::pb::calibrationTable*>(
      ::pb::calibrationTable::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->bt_ = const_cast< ::pb::biexpTrans*>(
      ::pb::biexpTrans::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->lt_ = const_cast< ::pb::logTrans*>(
      ::pb::logTrans::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->flt_ = const_cast< ::pb::flinTrans*>(
      ::pb::flinTrans::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->st_ = const_cast< ::pb::scaleTrans*>(
      ::pb::scaleTrans::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->ft_ = const_cast< ::pb::fasinhTrans*>(
      ::pb::fasinhTrans::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->lgt_ = const_cast< ::pb::logicleTrans*>(
      ::pb::logicleTrans::internal_default_instance());
  ::pb::_transformation_default_instance_._instance.get_mutable()->lgml2t_ = const_cast< ::pb::logGML2Trans*>(
      ::pb::logGML2Trans::internal_default_instance());
}
class transformation::HasBitSetters {
 public:
  static const ::pb::calibrationTable& caltbl(const transformation* msg);
  static const ::pb::biexpTrans& bt(const transformation* msg);
  static const ::pb::logTrans& lt(const transformation* msg);
  static const ::pb::flinTrans& flt(const transformation* msg);
  static const ::pb::scaleTrans& st(const transformation* msg);
  static const ::pb::fasinhTrans& ft(const transformation* msg);
  static const ::pb::logicleTrans& lgt(const transformation* msg);
  static const ::pb::logGML2Trans& lgml2t(const transformation* msg);
};

const ::pb::calibrationTable&
transformation::HasBitSetters::caltbl(const transformation* msg) {
  return *msg->caltbl_;
}
const ::pb::biexpTrans&
transformation::HasBitSetters::bt(const transformation* msg) {
  return *msg->bt_;
}
const ::pb::logTrans&
transformation::HasBitSetters::lt(const transformation* msg) {
  return *msg->lt_;
}
const ::pb::flinTrans&
transformation::HasBitSetters::flt(const transformation* msg) {
  return *msg->flt_;
}
const ::pb::scaleTrans&
transformation::HasBitSetters::st(const transformation* msg) {
  return *msg->st_;
}
const ::pb::fasinhTrans&
transformation::HasBitSetters::ft(const transformation* msg) {
  return *msg->ft_;
}
const ::pb::logicleTrans&
transformation::HasBitSetters::lgt(const transformation* msg) {
  return *msg->lgt_;
}
const ::pb::logGML2Trans&
transformation::HasBitSetters::lgml2t(const transformation* msg) {
  return *msg->lgml2t_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int transformation::kCalTblFieldNumber;
const int transformation::kIsGateOnlyFieldNumber;
const int transformation::kNameFieldNumber;
const int transformation::kChannelFieldNumber;
const int transformation::kIsComputedFieldNumber;
const int transformation::kTypeFieldNumber;
const int transformation::kTransTypeFieldNumber;
const int transformation::kBtFieldNumber;
const int transformation::kLtFieldNumber;
const int transformation::kFltFieldNumber;
const int transformation::kStFieldNumber;
const int transformation::kFtFieldNumber;
const int transformation::kLgtFieldNumber;
const int transformation::kLgml2TFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

transformation::transformation()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.transformation)
}
transformation::transformation(const transformation& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.name().size() > 0) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  channel_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.channel().size() > 0) {
    channel_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.channel_);
  }
  if (from.has_caltbl()) {
    caltbl_ = new ::pb::calibrationTable(*from.caltbl_);
  } else {
    caltbl_ = nullptr;
  }
  if (from.has_bt()) {
    bt_ = new ::pb::biexpTrans(*from.bt_);
  } else {
    bt_ = nullptr;
  }
  if (from.has_lt()) {
    lt_ = new ::pb::logTrans(*from.lt_);
  } else {
    lt_ = nullptr;
  }
  if (from.has_flt()) {
    flt_ = new ::pb::flinTrans(*from.flt_);
  } else {
    flt_ = nullptr;
  }
  if (from.has_st()) {
    st_ = new ::pb::scaleTrans(*from.st_);
  } else {
    st_ = nullptr;
  }
  if (from.has_ft()) {
    ft_ = new ::pb::fasinhTrans(*from.ft_);
  } else {
    ft_ = nullptr;
  }
  if (from.has_lgt()) {
    lgt_ = new ::pb::logicleTrans(*from.lgt_);
  } else {
    lgt_ = nullptr;
  }
  if (from.has_lgml2t()) {
    lgml2t_ = new ::pb::logGML2Trans(*from.lgml2t_);
  } else {
    lgml2t_ = nullptr;
  }
  ::memcpy(&trans_type_, &from.trans_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&trans_type_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:pb.transformation)
}

void transformation::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_transformation_GatingSet_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  channel_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&caltbl_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&caltbl_)) + sizeof(type_));
}

transformation::~transformation() {
  // @@protoc_insertion_point(destructor:pb.transformation)
  SharedDtor();
}

void transformation::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  channel_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete caltbl_;
  if (this != internal_default_instance()) delete bt_;
  if (this != internal_default_instance()) delete lt_;
  if (this != internal_default_instance()) delete flt_;
  if (this != internal_default_instance()) delete st_;
  if (this != internal_default_instance()) delete ft_;
  if (this != internal_default_instance()) delete lgt_;
  if (this != internal_default_instance()) delete lgml2t_;
}

void transformation::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const transformation& transformation::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_transformation_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void transformation::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.transformation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  channel_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == nullptr && caltbl_ != nullptr) {
    delete caltbl_;
  }
  caltbl_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && bt_ != nullptr) {
    delete bt_;
  }
  bt_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && lt_ != nullptr) {
    delete lt_;
  }
  lt_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && flt_ != nullptr) {
    delete flt_;
  }
  flt_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && st_ != nullptr) {
    delete st_;
  }
  st_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && ft_ != nullptr) {
    delete ft_;
  }
  ft_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && lgt_ != nullptr) {
    delete lgt_;
  }
  lgt_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && lgml2t_ != nullptr) {
    delete lgml2t_;
  }
  lgml2t_ = nullptr;
  ::memset(&trans_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&trans_type_)) + sizeof(type_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* transformation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .pb.calibrationTable calTbl = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_caltbl(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isGateOnly = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          isgateonly_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.TRANS_TYPE trans_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_trans_type(static_cast<::pb::TRANS_TYPE>(val));
        } else goto handle_unusual;
        continue;
      // string name = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "pb.transformation.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string channel = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_channel(), ptr, ctx, "pb.transformation.channel");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isComputed = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          iscomputed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.biexpTrans bt = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(mutable_bt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.logTrans lt = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(mutable_lt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.flinTrans flt = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(mutable_flt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.scaleTrans st = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(mutable_st(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.fasinhTrans ft = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(mutable_ft(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 type = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) {
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.logicleTrans lgt = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(mutable_lgt(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.logGML2Trans lgml2t = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(mutable_lgml2t(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool transformation::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.transformation)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .pb.calibrationTable calTbl = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_caltbl()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isGateOnly = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isgateonly_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.TRANS_TYPE trans_type = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_trans_type(static_cast< ::pb::TRANS_TYPE >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string name = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->name().data(), static_cast<int>(this->name().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.transformation.name"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string channel = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_channel()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->channel().data(), static_cast<int>(this->channel().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.transformation.channel"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isComputed = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &iscomputed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.biexpTrans bt = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_bt()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.logTrans lt = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_lt()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.flinTrans flt = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (74 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_flt()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.scaleTrans st = 10;
      case 10: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (82 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_st()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.fasinhTrans ft = 11;
      case 11: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (90 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_ft()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 type = 12;
      case 12: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (96 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.logicleTrans lgt = 13;
      case 13: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (106 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_lgt()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.logGML2Trans lgml2t = 14;
      case 14: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (114 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_lgml2t()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.transformation)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.transformation)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void transformation::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.transformation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.calibrationTable calTbl = 1;
  if (this->has_caltbl()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, HasBitSetters::caltbl(this), output);
  }

  // bool isGateOnly = 2;
  if (this->isgateonly() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->isgateonly(), output);
  }

  // .pb.TRANS_TYPE trans_type = 3;
  if (this->trans_type() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      3, this->trans_type(), output);
  }

  // string name = 4;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.transformation.name");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->name(), output);
  }

  // string channel = 5;
  if (this->channel().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->channel().data(), static_cast<int>(this->channel().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.transformation.channel");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->channel(), output);
  }

  // bool isComputed = 6;
  if (this->iscomputed() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->iscomputed(), output);
  }

  // .pb.biexpTrans bt = 7;
  if (this->has_bt()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, HasBitSetters::bt(this), output);
  }

  // .pb.logTrans lt = 8;
  if (this->has_lt()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, HasBitSetters::lt(this), output);
  }

  // .pb.flinTrans flt = 9;
  if (this->has_flt()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, HasBitSetters::flt(this), output);
  }

  // .pb.scaleTrans st = 10;
  if (this->has_st()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      10, HasBitSetters::st(this), output);
  }

  // .pb.fasinhTrans ft = 11;
  if (this->has_ft()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      11, HasBitSetters::ft(this), output);
  }

  // uint32 type = 12;
  if (this->type() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(12, this->type(), output);
  }

  // .pb.logicleTrans lgt = 13;
  if (this->has_lgt()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      13, HasBitSetters::lgt(this), output);
  }

  // .pb.logGML2Trans lgml2t = 14;
  if (this->has_lgml2t()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      14, HasBitSetters::lgml2t(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.transformation)
}

::PROTOBUF_NAMESPACE_ID::uint8* transformation::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.transformation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.calibrationTable calTbl = 1;
  if (this->has_caltbl()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, HasBitSetters::caltbl(this), target);
  }

  // bool isGateOnly = 2;
  if (this->isgateonly() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->isgateonly(), target);
  }

  // .pb.TRANS_TYPE trans_type = 3;
  if (this->trans_type() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->trans_type(), target);
  }

  // string name = 4;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.transformation.name");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        4, this->name(), target);
  }

  // string channel = 5;
  if (this->channel().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->channel().data(), static_cast<int>(this->channel().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.transformation.channel");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        5, this->channel(), target);
  }

  // bool isComputed = 6;
  if (this->iscomputed() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->iscomputed(), target);
  }

  // .pb.biexpTrans bt = 7;
  if (this->has_bt()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        7, HasBitSetters::bt(this), target);
  }

  // .pb.logTrans lt = 8;
  if (this->has_lt()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, HasBitSetters::lt(this), target);
  }

  // .pb.flinTrans flt = 9;
  if (this->has_flt()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        9, HasBitSetters::flt(this), target);
  }

  // .pb.scaleTrans st = 10;
  if (this->has_st()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        10, HasBitSetters::st(this), target);
  }

  // .pb.fasinhTrans ft = 11;
  if (this->has_ft()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        11, HasBitSetters::ft(this), target);
  }

  // uint32 type = 12;
  if (this->type() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(12, this->type(), target);
  }

  // .pb.logicleTrans lgt = 13;
  if (this->has_lgt()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        13, HasBitSetters::lgt(this), target);
  }

  // .pb.logGML2Trans lgml2t = 14;
  if (this->has_lgml2t()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        14, HasBitSetters::lgml2t(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.transformation)
  return target;
}

size_t transformation::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.transformation)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string name = 4;
  if (this->name().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->name());
  }

  // string channel = 5;
  if (this->channel().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->channel());
  }

  // .pb.calibrationTable calTbl = 1;
  if (this->has_caltbl()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *caltbl_);
  }

  // .pb.biexpTrans bt = 7;
  if (this->has_bt()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *bt_);
  }

  // .pb.logTrans lt = 8;
  if (this->has_lt()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *lt_);
  }

  // .pb.flinTrans flt = 9;
  if (this->has_flt()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *flt_);
  }

  // .pb.scaleTrans st = 10;
  if (this->has_st()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *st_);
  }

  // .pb.fasinhTrans ft = 11;
  if (this->has_ft()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *ft_);
  }

  // .pb.logicleTrans lgt = 13;
  if (this->has_lgt()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *lgt_);
  }

  // .pb.logGML2Trans lgml2t = 14;
  if (this->has_lgml2t()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *lgml2t_);
  }

  // .pb.TRANS_TYPE trans_type = 3;
  if (this->trans_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->trans_type());
  }

  // bool isGateOnly = 2;
  if (this->isgateonly() != 0) {
    total_size += 1 + 1;
  }

  // bool isComputed = 6;
  if (this->iscomputed() != 0) {
    total_size += 1 + 1;
  }

  // uint32 type = 12;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->type());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void transformation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.transformation)
  GOOGLE_DCHECK_NE(&from, this);
  const transformation* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<transformation>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.transformation)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.transformation)
    MergeFrom(*source);
  }
}

void transformation::MergeFrom(const transformation& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.transformation)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.name().size() > 0) {

    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.channel().size() > 0) {

    channel_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.channel_);
  }
  if (from.has_caltbl()) {
    mutable_caltbl()->::pb::calibrationTable::MergeFrom(from.caltbl());
  }
  if (from.has_bt()) {
    mutable_bt()->::pb::biexpTrans::MergeFrom(from.bt());
  }
  if (from.has_lt()) {
    mutable_lt()->::pb::logTrans::MergeFrom(from.lt());
  }
  if (from.has_flt()) {
    mutable_flt()->::pb::flinTrans::MergeFrom(from.flt());
  }
  if (from.has_st()) {
    mutable_st()->::pb::scaleTrans::MergeFrom(from.st());
  }
  if (from.has_ft()) {
    mutable_ft()->::pb::fasinhTrans::MergeFrom(from.ft());
  }
  if (from.has_lgt()) {
    mutable_lgt()->::pb::logicleTrans::MergeFrom(from.lgt());
  }
  if (from.has_lgml2t()) {
    mutable_lgml2t()->::pb::logGML2Trans::MergeFrom(from.lgml2t());
  }
  if (from.trans_type() != 0) {
    set_trans_type(from.trans_type());
  }
  if (from.isgateonly() != 0) {
    set_isgateonly(from.isgateonly());
  }
  if (from.iscomputed() != 0) {
    set_iscomputed(from.iscomputed());
  }
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void transformation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.transformation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void transformation::CopyFrom(const transformation& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.transformation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool transformation::IsInitialized() const {
  return true;
}

void transformation::Swap(transformation* other) {
  if (other == this) return;
  InternalSwap(other);
}
void transformation::InternalSwap(transformation* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  channel_.Swap(&other->channel_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(caltbl_, other->caltbl_);
  swap(bt_, other->bt_);
  swap(lt_, other->lt_);
  swap(flt_, other->flt_);
  swap(st_, other->st_);
  swap(ft_, other->ft_);
  swap(lgt_, other->lgt_);
  swap(lgml2t_, other->lgml2t_);
  swap(trans_type_, other->trans_type_);
  swap(isgateonly_, other->isgateonly_);
  swap(iscomputed_, other->iscomputed_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata transformation::GetMetadata() const {
  return GetMetadataStatic();
}


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

void trans_pair::InitAsDefaultInstance() {
  ::pb::_trans_pair_default_instance_._instance.get_mutable()->trans_ = const_cast< ::pb::transformation*>(
      ::pb::transformation::internal_default_instance());
}
class trans_pair::HasBitSetters {
 public:
  static const ::pb::transformation& trans(const trans_pair* msg);
};

const ::pb::transformation&
trans_pair::HasBitSetters::trans(const trans_pair* msg) {
  return *msg->trans_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int trans_pair::kNameFieldNumber;
const int trans_pair::kTransAddressFieldNumber;
const int trans_pair::kTransFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

trans_pair::trans_pair()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.trans_pair)
}
trans_pair::trans_pair(const trans_pair& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.name().size() > 0) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.has_trans()) {
    trans_ = new ::pb::transformation(*from.trans_);
  } else {
    trans_ = nullptr;
  }
  trans_address_ = from.trans_address_;
  // @@protoc_insertion_point(copy_constructor:pb.trans_pair)
}

void trans_pair::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_trans_pair_GatingSet_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&trans_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&trans_address_) -
      reinterpret_cast<char*>(&trans_)) + sizeof(trans_address_));
}

trans_pair::~trans_pair() {
  // @@protoc_insertion_point(destructor:pb.trans_pair)
  SharedDtor();
}

void trans_pair::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete trans_;
}

void trans_pair::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const trans_pair& trans_pair::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_trans_pair_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void trans_pair::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.trans_pair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == nullptr && trans_ != nullptr) {
    delete trans_;
  }
  trans_ = nullptr;
  trans_address_ = PROTOBUF_ULONGLONG(0);
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* trans_pair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "pb.trans_pair.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint64 trans_address = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          trans_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.transformation trans = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(mutable_trans(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool trans_pair::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.trans_pair)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string name = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->name().data(), static_cast<int>(this->name().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.trans_pair.name"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint64 trans_address = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &trans_address_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.transformation trans = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_trans()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.trans_pair)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.trans_pair)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void trans_pair::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.trans_pair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string name = 1;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.trans_pair.name");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // uint64 trans_address = 2;
  if (this->trans_address() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->trans_address(), output);
  }

  // .pb.transformation trans = 3;
  if (this->has_trans()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, HasBitSetters::trans(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.trans_pair)
}

::PROTOBUF_NAMESPACE_ID::uint8* trans_pair::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.trans_pair)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string name = 1;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.trans_pair.name");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // uint64 trans_address = 2;
  if (this->trans_address() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->trans_address(), target);
  }

  // .pb.transformation trans = 3;
  if (this->has_trans()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, HasBitSetters::trans(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.trans_pair)
  return target;
}

size_t trans_pair::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.trans_pair)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string name = 1;
  if (this->name().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->name());
  }

  // .pb.transformation trans = 3;
  if (this->has_trans()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *trans_);
  }

  // uint64 trans_address = 2;
  if (this->trans_address() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->trans_address());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void trans_pair::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.trans_pair)
  GOOGLE_DCHECK_NE(&from, this);
  const trans_pair* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<trans_pair>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.trans_pair)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.trans_pair)
    MergeFrom(*source);
  }
}

void trans_pair::MergeFrom(const trans_pair& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.trans_pair)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.name().size() > 0) {

    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.has_trans()) {
    mutable_trans()->::pb::transformation::MergeFrom(from.trans());
  }
  if (from.trans_address() != 0) {
    set_trans_address(from.trans_address());
  }
}

void trans_pair::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.trans_pair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void trans_pair::CopyFrom(const trans_pair& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.trans_pair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool trans_pair::IsInitialized() const {
  return true;
}

void trans_pair::Swap(trans_pair* other) {
  if (other == this) return;
  InternalSwap(other);
}
void trans_pair::InternalSwap(trans_pair* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(trans_, other->trans_);
  swap(trans_address_, other->trans_address_);
}

::PROTOBUF_NAMESPACE_ID::Metadata trans_pair::GetMetadata() const {
  return GetMetadataStatic();
}


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

void trans_local::InitAsDefaultInstance() {
}
class trans_local::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int trans_local::kTpFieldNumber;
const int trans_local::kGroupNameFieldNumber;
const int trans_local::kSampleIDsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

trans_local::trans_local()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.trans_local)
}
trans_local::trans_local(const trans_local& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      tp_(from.tp_),
      sampleids_(from.sampleids_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  groupname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.groupname().size() > 0) {
    groupname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.groupname_);
  }
  // @@protoc_insertion_point(copy_constructor:pb.trans_local)
}

void trans_local::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_trans_local_GatingSet_2eproto.base);
  groupname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

trans_local::~trans_local() {
  // @@protoc_insertion_point(destructor:pb.trans_local)
  SharedDtor();
}

void trans_local::SharedDtor() {
  groupname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void trans_local::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const trans_local& trans_local::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_trans_local_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void trans_local::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.trans_local)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  tp_.Clear();
  sampleids_.Clear();
  groupname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* trans_local::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .pb.trans_pair tp = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_tp(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      // string groupName = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_groupname(), ptr, ctx, "pb.trans_local.groupName");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated uint32 sampleIDs = 3 [packed = true];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(mutable_sampleids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
          add_sampleids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool trans_local::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.trans_local)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .pb.trans_pair tp = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_tp()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string groupName = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_groupname()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->groupname().data(), static_cast<int>(this->groupname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.trans_local.groupName"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 sampleIDs = 3 [packed = true];
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_sampleids())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 1, 26u, input, this->mutable_sampleids())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.trans_local)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.trans_local)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void trans_local::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.trans_local)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .pb.trans_pair tp = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tp_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1,
      this->tp(static_cast<int>(i)),
      output);
  }

  // string groupName = 2;
  if (this->groupname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->groupname().data(), static_cast<int>(this->groupname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.trans_local.groupName");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->groupname(), output);
  }

  // repeated uint32 sampleIDs = 3 [packed = true];
  if (this->sampleids_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_sampleids_cached_byte_size_.load(
        std::memory_order_relaxed));
  }
  for (int i = 0, n = this->sampleids_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32NoTag(
      this->sampleids(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.trans_local)
}

::PROTOBUF_NAMESPACE_ID::uint8* trans_local::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.trans_local)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .pb.trans_pair tp = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->tp_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->tp(static_cast<int>(i)), target);
  }

  // string groupName = 2;
  if (this->groupname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->groupname().data(), static_cast<int>(this->groupname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.trans_local.groupName");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->groupname(), target);
  }

  // repeated uint32 sampleIDs = 3 [packed = true];
  if (this->sampleids_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      3,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _sampleids_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteUInt32NoTagToArray(this->sampleids_, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.trans_local)
  return target;
}

size_t trans_local::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.trans_local)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .pb.trans_pair tp = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->tp_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->tp(static_cast<int>(i)));
    }
  }

  // repeated uint32 sampleIDs = 3 [packed = true];
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt32Size(this->sampleids_);
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _sampleids_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // string groupName = 2;
  if (this->groupname().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->groupname());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void trans_local::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.trans_local)
  GOOGLE_DCHECK_NE(&from, this);
  const trans_local* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<trans_local>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.trans_local)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.trans_local)
    MergeFrom(*source);
  }
}

void trans_local::MergeFrom(const trans_local& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.trans_local)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  tp_.MergeFrom(from.tp_);
  sampleids_.MergeFrom(from.sampleids_);
  if (from.groupname().size() > 0) {

    groupname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.groupname_);
  }
}

void trans_local::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.trans_local)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void trans_local::CopyFrom(const trans_local& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.trans_local)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool trans_local::IsInitialized() const {
  return true;
}

void trans_local::Swap(trans_local* other) {
  if (other == this) return;
  InternalSwap(other);
}
void trans_local::InternalSwap(trans_local* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&tp_)->InternalSwap(CastToBase(&other->tp_));
  sampleids_.InternalSwap(&other->sampleids_);
  groupname_.Swap(&other->groupname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata trans_local::GetMetadata() const {
  return GetMetadataStatic();
}


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

void POPINDICES::InitAsDefaultInstance() {
}
class POPINDICES::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int POPINDICES::kNEventsFieldNumber;
const int POPINDICES::kIndtypeFieldNumber;
const int POPINDICES::kIIndFieldNumber;
const int POPINDICES::kBIndFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

POPINDICES::POPINDICES()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.POPINDICES)
}
POPINDICES::POPINDICES(const POPINDICES& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      iind_(from.iind_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  bind_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.bind().size() > 0) {
    bind_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bind_);
  }
  ::memcpy(&nevents_, &from.nevents_,
    static_cast<size_t>(reinterpret_cast<char*>(&indtype_) -
    reinterpret_cast<char*>(&nevents_)) + sizeof(indtype_));
  // @@protoc_insertion_point(copy_constructor:pb.POPINDICES)
}

void POPINDICES::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_POPINDICES_GatingSet_2eproto.base);
  bind_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&nevents_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&indtype_) -
      reinterpret_cast<char*>(&nevents_)) + sizeof(indtype_));
}

POPINDICES::~POPINDICES() {
  // @@protoc_insertion_point(destructor:pb.POPINDICES)
  SharedDtor();
}

void POPINDICES::SharedDtor() {
  bind_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void POPINDICES::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const POPINDICES& POPINDICES::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_POPINDICES_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void POPINDICES::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.POPINDICES)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  iind_.Clear();
  bind_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&nevents_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&indtype_) -
      reinterpret_cast<char*>(&nevents_)) + sizeof(indtype_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* POPINDICES::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // uint32 nEvents = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          nevents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.ind_type indtype = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_indtype(static_cast<::pb::ind_type>(val));
        } else goto handle_unusual;
        continue;
      // repeated uint32 iInd = 3 [packed = true];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(mutable_iind(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
          add_iind(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bytes bInd = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_bind(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool POPINDICES::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.POPINDICES)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // uint32 nEvents = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &nevents_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.ind_type indtype = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_indtype(static_cast< ::pb::ind_type >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 iInd = 3 [packed = true];
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_iind())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 1, 26u, input, this->mutable_iind())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bytes bInd = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_bind()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.POPINDICES)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.POPINDICES)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void POPINDICES::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.POPINDICES)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 nEvents = 1;
  if (this->nevents() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->nevents(), output);
  }

  // .pb.ind_type indtype = 2;
  if (this->indtype() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->indtype(), output);
  }

  // repeated uint32 iInd = 3 [packed = true];
  if (this->iind_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_iind_cached_byte_size_.load(
        std::memory_order_relaxed));
  }
  for (int i = 0, n = this->iind_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32NoTag(
      this->iind(i), output);
  }

  // bytes bInd = 4;
  if (this->bind().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->bind(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.POPINDICES)
}

::PROTOBUF_NAMESPACE_ID::uint8* POPINDICES::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.POPINDICES)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint32 nEvents = 1;
  if (this->nevents() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->nevents(), target);
  }

  // .pb.ind_type indtype = 2;
  if (this->indtype() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->indtype(), target);
  }

  // repeated uint32 iInd = 3 [packed = true];
  if (this->iind_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      3,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _iind_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteUInt32NoTagToArray(this->iind_, target);
  }

  // bytes bInd = 4;
  if (this->bind().size() > 0) {
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray(
        4, this->bind(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.POPINDICES)
  return target;
}

size_t POPINDICES::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.POPINDICES)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated uint32 iInd = 3 [packed = true];
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt32Size(this->iind_);
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _iind_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // bytes bInd = 4;
  if (this->bind().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->bind());
  }

  // uint32 nEvents = 1;
  if (this->nevents() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->nevents());
  }

  // .pb.ind_type indtype = 2;
  if (this->indtype() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->indtype());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void POPINDICES::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.POPINDICES)
  GOOGLE_DCHECK_NE(&from, this);
  const POPINDICES* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<POPINDICES>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.POPINDICES)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.POPINDICES)
    MergeFrom(*source);
  }
}

void POPINDICES::MergeFrom(const POPINDICES& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.POPINDICES)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  iind_.MergeFrom(from.iind_);
  if (from.bind().size() > 0) {

    bind_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bind_);
  }
  if (from.nevents() != 0) {
    set_nevents(from.nevents());
  }
  if (from.indtype() != 0) {
    set_indtype(from.indtype());
  }
}

void POPINDICES::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.POPINDICES)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void POPINDICES::CopyFrom(const POPINDICES& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.POPINDICES)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool POPINDICES::IsInitialized() const {
  return true;
}

void POPINDICES::Swap(POPINDICES* other) {
  if (other == this) return;
  InternalSwap(other);
}
void POPINDICES::InternalSwap(POPINDICES* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  iind_.InternalSwap(&other->iind_);
  bind_.Swap(&other->bind_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(nevents_, other->nevents_);
  swap(indtype_, other->indtype_);
}

::PROTOBUF_NAMESPACE_ID::Metadata POPINDICES::GetMetadata() const {
  return GetMetadataStatic();
}


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

void nodeProperties::InitAsDefaultInstance() {
  ::pb::_nodeProperties_default_instance_._instance.get_mutable()->indices_ = const_cast< ::pb::POPINDICES*>(
      ::pb::POPINDICES::internal_default_instance());
  ::pb::_nodeProperties_default_instance_._instance.get_mutable()->thisgate_ = const_cast< ::pb::gate*>(
      ::pb::gate::internal_default_instance());
}
class nodeProperties::HasBitSetters {
 public:
  static const ::pb::POPINDICES& indices(const nodeProperties* msg);
  static const ::pb::gate& thisgate(const nodeProperties* msg);
};

const ::pb::POPINDICES&
nodeProperties::HasBitSetters::indices(const nodeProperties* msg) {
  return *msg->indices_;
}
const ::pb::gate&
nodeProperties::HasBitSetters::thisgate(const nodeProperties* msg) {
  return *msg->thisgate_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int nodeProperties::kThisNameFieldNumber;
const int nodeProperties::kFjStatsFieldNumber;
const int nodeProperties::kFcStatsFieldNumber;
const int nodeProperties::kHiddenFieldNumber;
const int nodeProperties::kIndicesFieldNumber;
const int nodeProperties::kThisGateFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

nodeProperties::nodeProperties()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.nodeProperties)
}
nodeProperties::nodeProperties(const nodeProperties& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      fjstats_(from.fjstats_),
      fcstats_(from.fcstats_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  thisname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.thisname().size() > 0) {
    thisname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.thisname_);
  }
  if (from.has_indices()) {
    indices_ = new ::pb::POPINDICES(*from.indices_);
  } else {
    indices_ = nullptr;
  }
  if (from.has_thisgate()) {
    thisgate_ = new ::pb::gate(*from.thisgate_);
  } else {
    thisgate_ = nullptr;
  }
  hidden_ = from.hidden_;
  // @@protoc_insertion_point(copy_constructor:pb.nodeProperties)
}

void nodeProperties::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_nodeProperties_GatingSet_2eproto.base);
  thisname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&indices_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&hidden_) -
      reinterpret_cast<char*>(&indices_)) + sizeof(hidden_));
}

nodeProperties::~nodeProperties() {
  // @@protoc_insertion_point(destructor:pb.nodeProperties)
  SharedDtor();
}

void nodeProperties::SharedDtor() {
  thisname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete indices_;
  if (this != internal_default_instance()) delete thisgate_;
}

void nodeProperties::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const nodeProperties& nodeProperties::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_nodeProperties_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void nodeProperties::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.nodeProperties)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  fjstats_.Clear();
  fcstats_.Clear();
  thisname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == nullptr && indices_ != nullptr) {
    delete indices_;
  }
  indices_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && thisgate_ != nullptr) {
    delete thisgate_;
  }
  thisgate_ = nullptr;
  hidden_ = false;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* nodeProperties::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string thisName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_thisname(), ptr, ctx, "pb.nodeProperties.thisName");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .pb.POPSTATS fjStats = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_fjstats(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      // repeated .pb.POPSTATS fcStats = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_fcstats(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
        } else goto handle_unusual;
        continue;
      // bool hidden = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          hidden_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.POPINDICES indices = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_indices(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.gate thisGate = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(mutable_thisgate(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool nodeProperties::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.nodeProperties)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string thisName = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_thisname()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->thisname().data(), static_cast<int>(this->thisname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.nodeProperties.thisName"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.POPSTATS fjStats = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_fjstats()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.POPSTATS fcStats = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_fcstats()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool hidden = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &hidden_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.POPINDICES indices = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_indices()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.gate thisGate = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_thisgate()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.nodeProperties)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.nodeProperties)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void nodeProperties::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.nodeProperties)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string thisName = 1;
  if (this->thisname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->thisname().data(), static_cast<int>(this->thisname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.nodeProperties.thisName");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->thisname(), output);
  }

  // repeated .pb.POPSTATS fjStats = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->fjstats_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2,
      this->fjstats(static_cast<int>(i)),
      output);
  }

  // repeated .pb.POPSTATS fcStats = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->fcstats_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      3,
      this->fcstats(static_cast<int>(i)),
      output);
  }

  // bool hidden = 4;
  if (this->hidden() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(4, this->hidden(), output);
  }

  // .pb.POPINDICES indices = 5;
  if (this->has_indices()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, HasBitSetters::indices(this), output);
  }

  // .pb.gate thisGate = 6;
  if (this->has_thisgate()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, HasBitSetters::thisgate(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.nodeProperties)
}

::PROTOBUF_NAMESPACE_ID::uint8* nodeProperties::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.nodeProperties)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string thisName = 1;
  if (this->thisname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->thisname().data(), static_cast<int>(this->thisname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.nodeProperties.thisName");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->thisname(), target);
  }

  // repeated .pb.POPSTATS fjStats = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->fjstats_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->fjstats(static_cast<int>(i)), target);
  }

  // repeated .pb.POPSTATS fcStats = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->fcstats_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, this->fcstats(static_cast<int>(i)), target);
  }

  // bool hidden = 4;
  if (this->hidden() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->hidden(), target);
  }

  // .pb.POPINDICES indices = 5;
  if (this->has_indices()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, HasBitSetters::indices(this), target);
  }

  // .pb.gate thisGate = 6;
  if (this->has_thisgate()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, HasBitSetters::thisgate(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.nodeProperties)
  return target;
}

size_t nodeProperties::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.nodeProperties)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .pb.POPSTATS fjStats = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->fjstats_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->fjstats(static_cast<int>(i)));
    }
  }

  // repeated .pb.POPSTATS fcStats = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->fcstats_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->fcstats(static_cast<int>(i)));
    }
  }

  // string thisName = 1;
  if (this->thisname().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->thisname());
  }

  // .pb.POPINDICES indices = 5;
  if (this->has_indices()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *indices_);
  }

  // .pb.gate thisGate = 6;
  if (this->has_thisgate()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *thisgate_);
  }

  // bool hidden = 4;
  if (this->hidden() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void nodeProperties::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.nodeProperties)
  GOOGLE_DCHECK_NE(&from, this);
  const nodeProperties* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<nodeProperties>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.nodeProperties)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.nodeProperties)
    MergeFrom(*source);
  }
}

void nodeProperties::MergeFrom(const nodeProperties& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.nodeProperties)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  fjstats_.MergeFrom(from.fjstats_);
  fcstats_.MergeFrom(from.fcstats_);
  if (from.thisname().size() > 0) {

    thisname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.thisname_);
  }
  if (from.has_indices()) {
    mutable_indices()->::pb::POPINDICES::MergeFrom(from.indices());
  }
  if (from.has_thisgate()) {
    mutable_thisgate()->::pb::gate::MergeFrom(from.thisgate());
  }
  if (from.hidden() != 0) {
    set_hidden(from.hidden());
  }
}

void nodeProperties::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.nodeProperties)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void nodeProperties::CopyFrom(const nodeProperties& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.nodeProperties)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool nodeProperties::IsInitialized() const {
  return true;
}

void nodeProperties::Swap(nodeProperties* other) {
  if (other == this) return;
  InternalSwap(other);
}
void nodeProperties::InternalSwap(nodeProperties* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&fjstats_)->InternalSwap(CastToBase(&other->fjstats_));
  CastToBase(&fcstats_)->InternalSwap(CastToBase(&other->fcstats_));
  thisname_.Swap(&other->thisname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(indices_, other->indices_);
  swap(thisgate_, other->thisgate_);
  swap(hidden_, other->hidden_);
}

::PROTOBUF_NAMESPACE_ID::Metadata nodeProperties::GetMetadata() const {
  return GetMetadataStatic();
}


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

void treeNodes::InitAsDefaultInstance() {
  ::pb::_treeNodes_default_instance_._instance.get_mutable()->node_ = const_cast< ::pb::nodeProperties*>(
      ::pb::nodeProperties::internal_default_instance());
}
class treeNodes::HasBitSetters {
 public:
  static const ::pb::nodeProperties& node(const treeNodes* msg);
};

const ::pb::nodeProperties&
treeNodes::HasBitSetters::node(const treeNodes* msg) {
  return *msg->node_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int treeNodes::kNodeFieldNumber;
const int treeNodes::kParentFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

treeNodes::treeNodes()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.treeNodes)
}
treeNodes::treeNodes(const treeNodes& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_node()) {
    node_ = new ::pb::nodeProperties(*from.node_);
  } else {
    node_ = nullptr;
  }
  parent_ = from.parent_;
  // @@protoc_insertion_point(copy_constructor:pb.treeNodes)
}

void treeNodes::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_treeNodes_GatingSet_2eproto.base);
  ::memset(&node_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&parent_) -
      reinterpret_cast<char*>(&node_)) + sizeof(parent_));
}

treeNodes::~treeNodes() {
  // @@protoc_insertion_point(destructor:pb.treeNodes)
  SharedDtor();
}

void treeNodes::SharedDtor() {
  if (this != internal_default_instance()) delete node_;
}

void treeNodes::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const treeNodes& treeNodes::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_treeNodes_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void treeNodes::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.treeNodes)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && node_ != nullptr) {
    delete node_;
  }
  node_ = nullptr;
  parent_ = 0u;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* treeNodes::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .pb.nodeProperties node = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_node(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 parent = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          parent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool treeNodes::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.treeNodes)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .pb.nodeProperties node = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_node()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 parent = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &parent_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.treeNodes)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.treeNodes)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void treeNodes::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.treeNodes)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.nodeProperties node = 1;
  if (this->has_node()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, HasBitSetters::node(this), output);
  }

  // uint32 parent = 2;
  if (this->parent() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->parent(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.treeNodes)
}

::PROTOBUF_NAMESPACE_ID::uint8* treeNodes::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.treeNodes)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.nodeProperties node = 1;
  if (this->has_node()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, HasBitSetters::node(this), target);
  }

  // uint32 parent = 2;
  if (this->parent() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->parent(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.treeNodes)
  return target;
}

size_t treeNodes::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.treeNodes)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .pb.nodeProperties node = 1;
  if (this->has_node()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *node_);
  }

  // uint32 parent = 2;
  if (this->parent() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->parent());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void treeNodes::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.treeNodes)
  GOOGLE_DCHECK_NE(&from, this);
  const treeNodes* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<treeNodes>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.treeNodes)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.treeNodes)
    MergeFrom(*source);
  }
}

void treeNodes::MergeFrom(const treeNodes& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.treeNodes)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_node()) {
    mutable_node()->::pb::nodeProperties::MergeFrom(from.node());
  }
  if (from.parent() != 0) {
    set_parent(from.parent());
  }
}

void treeNodes::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.treeNodes)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void treeNodes::CopyFrom(const treeNodes& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.treeNodes)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool treeNodes::IsInitialized() const {
  return true;
}

void treeNodes::Swap(treeNodes* other) {
  if (other == this) return;
  InternalSwap(other);
}
void treeNodes::InternalSwap(treeNodes* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(node_, other->node_);
  swap(parent_, other->parent_);
}

::PROTOBUF_NAMESPACE_ID::Metadata treeNodes::GetMetadata() const {
  return GetMetadataStatic();
}


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

void populationTree::InitAsDefaultInstance() {
}
class populationTree::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int populationTree::kNodeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

populationTree::populationTree()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.populationTree)
}
populationTree::populationTree(const populationTree& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      node_(from.node_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:pb.populationTree)
}

void populationTree::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_populationTree_GatingSet_2eproto.base);
}

populationTree::~populationTree() {
  // @@protoc_insertion_point(destructor:pb.populationTree)
  SharedDtor();
}

void populationTree::SharedDtor() {
}

void populationTree::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const populationTree& populationTree::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_populationTree_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void populationTree::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.populationTree)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  node_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* populationTree::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .pb.treeNodes node = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_node(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool populationTree::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.populationTree)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .pb.treeNodes node = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_node()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.populationTree)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.populationTree)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void populationTree::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.populationTree)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .pb.treeNodes node = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->node_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1,
      this->node(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.populationTree)
}

::PROTOBUF_NAMESPACE_ID::uint8* populationTree::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.populationTree)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .pb.treeNodes node = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->node_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->node(static_cast<int>(i)), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.populationTree)
  return target;
}

size_t populationTree::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.populationTree)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .pb.treeNodes node = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->node_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->node(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void populationTree::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.populationTree)
  GOOGLE_DCHECK_NE(&from, this);
  const populationTree* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<populationTree>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.populationTree)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.populationTree)
    MergeFrom(*source);
  }
}

void populationTree::MergeFrom(const populationTree& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.populationTree)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  node_.MergeFrom(from.node_);
}

void populationTree::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.populationTree)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void populationTree::CopyFrom(const populationTree& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.populationTree)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool populationTree::IsInitialized() const {
  return true;
}

void populationTree::Swap(populationTree* other) {
  if (other == this) return;
  InternalSwap(other);
}
void populationTree::InternalSwap(populationTree* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&node_)->InternalSwap(CastToBase(&other->node_));
}

::PROTOBUF_NAMESPACE_ID::Metadata populationTree::GetMetadata() const {
  return GetMetadataStatic();
}


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

void COMP::InitAsDefaultInstance() {
}
class COMP::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int COMP::kCidFieldNumber;
const int COMP::kPrefixFieldNumber;
const int COMP::kSuffixFieldNumber;
const int COMP::kNameFieldNumber;
const int COMP::kCommentFieldNumber;
const int COMP::kMarkerFieldNumber;
const int COMP::kSpillOverFieldNumber;
const int COMP::kDetectorFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

COMP::COMP()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.COMP)
}
COMP::COMP(const COMP& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      marker_(from.marker_),
      spillover_(from.spillover_),
      detector_(from.detector_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  cid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.cid().size() > 0) {
    cid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cid_);
  }
  prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.prefix().size() > 0) {
    prefix_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.prefix_);
  }
  suffix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.suffix().size() > 0) {
    suffix_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.suffix_);
  }
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.name().size() > 0) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.comment().size() > 0) {
    comment_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.comment_);
  }
  // @@protoc_insertion_point(copy_constructor:pb.COMP)
}

void COMP::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_COMP_GatingSet_2eproto.base);
  cid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  suffix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

COMP::~COMP() {
  // @@protoc_insertion_point(destructor:pb.COMP)
  SharedDtor();
}

void COMP::SharedDtor() {
  cid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  suffix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  comment_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void COMP::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const COMP& COMP::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_COMP_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void COMP::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.COMP)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  marker_.Clear();
  spillover_.Clear();
  detector_.Clear();
  cid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  prefix_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  suffix_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  comment_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* COMP::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string cid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_cid(), ptr, ctx, "pb.COMP.cid");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string prefix = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_prefix(), ptr, ctx, "pb.COMP.prefix");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string suffix = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_suffix(), ptr, ctx, "pb.COMP.suffix");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string name = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "pb.COMP.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string comment = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_comment(), ptr, ctx, "pb.COMP.comment");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string marker = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_marker(), ptr, ctx, "pb.COMP.marker");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50);
        } else goto handle_unusual;
        continue;
      // repeated float spillOver = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_spillover(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61) {
          add_spillover(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // repeated string detector = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_detector(), ptr, ctx, "pb.COMP.detector");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 66);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool COMP::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.COMP)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string cid = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_cid()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->cid().data(), static_cast<int>(this->cid().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.cid"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string prefix = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_prefix()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->prefix().data(), static_cast<int>(this->prefix().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.prefix"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string suffix = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_suffix()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->suffix().data(), static_cast<int>(this->suffix().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.suffix"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string name = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->name().data(), static_cast<int>(this->name().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.name"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string comment = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_comment()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->comment().data(), static_cast<int>(this->comment().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.comment"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string marker = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->add_marker()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->marker(this->marker_size() - 1).data(),
            static_cast<int>(this->marker(this->marker_size() - 1).length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.marker"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated float spillOver = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_spillover())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (61 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 58u, input, this->mutable_spillover())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string detector = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->add_detector()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->detector(this->detector_size() - 1).data(),
            static_cast<int>(this->detector(this->detector_size() - 1).length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.COMP.detector"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.COMP)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.COMP)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void COMP::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.COMP)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string cid = 1;
  if (this->cid().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->cid().data(), static_cast<int>(this->cid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.cid");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->cid(), output);
  }

  // string prefix = 2;
  if (this->prefix().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->prefix().data(), static_cast<int>(this->prefix().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.prefix");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->prefix(), output);
  }

  // string suffix = 3;
  if (this->suffix().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->suffix().data(), static_cast<int>(this->suffix().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.suffix");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->suffix(), output);
  }

  // string name = 4;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.name");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->name(), output);
  }

  // string comment = 5;
  if (this->comment().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->comment().data(), static_cast<int>(this->comment().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.comment");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->comment(), output);
  }

  // repeated string marker = 6;
  for (int i = 0, n = this->marker_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->marker(i).data(), static_cast<int>(this->marker(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.marker");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
      6, this->marker(i), output);
  }

  // repeated float spillOver = 7;
  if (this->spillover_size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(7, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_spillover_cached_byte_size_.load(
        std::memory_order_relaxed));
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
      this->spillover().data(), this->spillover_size(), output);
  }

  // repeated string detector = 8;
  for (int i = 0, n = this->detector_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->detector(i).data(), static_cast<int>(this->detector(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.detector");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
      8, this->detector(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.COMP)
}

::PROTOBUF_NAMESPACE_ID::uint8* COMP::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.COMP)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string cid = 1;
  if (this->cid().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->cid().data(), static_cast<int>(this->cid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.cid");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->cid(), target);
  }

  // string prefix = 2;
  if (this->prefix().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->prefix().data(), static_cast<int>(this->prefix().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.prefix");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        2, this->prefix(), target);
  }

  // string suffix = 3;
  if (this->suffix().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->suffix().data(), static_cast<int>(this->suffix().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.suffix");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        3, this->suffix(), target);
  }

  // string name = 4;
  if (this->name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->name().data(), static_cast<int>(this->name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.name");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        4, this->name(), target);
  }

  // string comment = 5;
  if (this->comment().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->comment().data(), static_cast<int>(this->comment().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.comment");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        5, this->comment(), target);
  }

  // repeated string marker = 6;
  for (int i = 0, n = this->marker_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->marker(i).data(), static_cast<int>(this->marker(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.marker");
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteStringToArray(6, this->marker(i), target);
  }

  // repeated float spillOver = 7;
  if (this->spillover_size() > 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
      7,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
      target);
    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
        _spillover_cached_byte_size_.load(std::memory_order_relaxed),
         target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteFloatNoTagToArray(this->spillover_, target);
  }

  // repeated string detector = 8;
  for (int i = 0, n = this->detector_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->detector(i).data(), static_cast<int>(this->detector(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.COMP.detector");
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteStringToArray(8, this->detector(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.COMP)
  return target;
}

size_t COMP::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.COMP)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string marker = 6;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->marker_size());
  for (int i = 0, n = this->marker_size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      this->marker(i));
  }

  // repeated float spillOver = 7;
  {
    unsigned int count = static_cast<unsigned int>(this->spillover_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _spillover_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated string detector = 8;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->detector_size());
  for (int i = 0, n = this->detector_size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      this->detector(i));
  }

  // string cid = 1;
  if (this->cid().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->cid());
  }

  // string prefix = 2;
  if (this->prefix().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->prefix());
  }

  // string suffix = 3;
  if (this->suffix().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->suffix());
  }

  // string name = 4;
  if (this->name().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->name());
  }

  // string comment = 5;
  if (this->comment().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->comment());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void COMP::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.COMP)
  GOOGLE_DCHECK_NE(&from, this);
  const COMP* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<COMP>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.COMP)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.COMP)
    MergeFrom(*source);
  }
}

void COMP::MergeFrom(const COMP& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.COMP)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  marker_.MergeFrom(from.marker_);
  spillover_.MergeFrom(from.spillover_);
  detector_.MergeFrom(from.detector_);
  if (from.cid().size() > 0) {

    cid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cid_);
  }
  if (from.prefix().size() > 0) {

    prefix_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.prefix_);
  }
  if (from.suffix().size() > 0) {

    suffix_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.suffix_);
  }
  if (from.name().size() > 0) {

    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.comment().size() > 0) {

    comment_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.comment_);
  }
}

void COMP::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.COMP)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void COMP::CopyFrom(const COMP& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.COMP)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool COMP::IsInitialized() const {
  return true;
}

void COMP::Swap(COMP* other) {
  if (other == this) return;
  InternalSwap(other);
}
void COMP::InternalSwap(COMP* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  marker_.InternalSwap(CastToBase(&other->marker_));
  spillover_.InternalSwap(&other->spillover_);
  detector_.InternalSwap(CastToBase(&other->detector_));
  cid_.Swap(&other->cid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  prefix_.Swap(&other->prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  suffix_.Swap(&other->suffix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  comment_.Swap(&other->comment_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata COMP::GetMetadata() const {
  return GetMetadataStatic();
}


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

void PARAM::InitAsDefaultInstance() {
}
class PARAM::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PARAM::kParamFieldNumber;
const int PARAM::kLogFieldNumber;
const int PARAM::kRangeFieldNumber;
const int PARAM::kHighValueFieldNumber;
const int PARAM::kCalibrationIndexFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PARAM::PARAM()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.PARAM)
}
PARAM::PARAM(const PARAM& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.param().size() > 0) {
    param_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.param_);
  }
  ::memcpy(&log_, &from.log_,
    static_cast<size_t>(reinterpret_cast<char*>(&calibrationindex_) -
    reinterpret_cast<char*>(&log_)) + sizeof(calibrationindex_));
  // @@protoc_insertion_point(copy_constructor:pb.PARAM)
}

void PARAM::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PARAM_GatingSet_2eproto.base);
  param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&log_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&calibrationindex_) -
      reinterpret_cast<char*>(&log_)) + sizeof(calibrationindex_));
}

PARAM::~PARAM() {
  // @@protoc_insertion_point(destructor:pb.PARAM)
  SharedDtor();
}

void PARAM::SharedDtor() {
  param_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void PARAM::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PARAM& PARAM::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PARAM_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void PARAM::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.PARAM)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  param_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&log_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&calibrationindex_) -
      reinterpret_cast<char*>(&log_)) + sizeof(calibrationindex_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* PARAM::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string param = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_param(), ptr, ctx, "pb.PARAM.param");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool log = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          log_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 range = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          range_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 highValue = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          highvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 calibrationIndex = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          calibrationindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool PARAM::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.PARAM)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string param = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_param()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->param().data(), static_cast<int>(this->param().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.PARAM.param"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool log = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &log_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 range = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &range_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 highValue = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &highvalue_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint32 calibrationIndex = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &calibrationindex_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.PARAM)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.PARAM)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void PARAM::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.PARAM)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string param = 1;
  if (this->param().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->param().data(), static_cast<int>(this->param().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.PARAM.param");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->param(), output);
  }

  // bool log = 2;
  if (this->log() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->log(), output);
  }

  // uint32 range = 3;
  if (this->range() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->range(), output);
  }

  // uint32 highValue = 4;
  if (this->highvalue() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(4, this->highvalue(), output);
  }

  // uint32 calibrationIndex = 5;
  if (this->calibrationindex() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(5, this->calibrationindex(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.PARAM)
}

::PROTOBUF_NAMESPACE_ID::uint8* PARAM::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.PARAM)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string param = 1;
  if (this->param().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->param().data(), static_cast<int>(this->param().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.PARAM.param");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        1, this->param(), target);
  }

  // bool log = 2;
  if (this->log() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->log(), target);
  }

  // uint32 range = 3;
  if (this->range() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->range(), target);
  }

  // uint32 highValue = 4;
  if (this->highvalue() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->highvalue(), target);
  }

  // uint32 calibrationIndex = 5;
  if (this->calibrationindex() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->calibrationindex(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.PARAM)
  return target;
}

size_t PARAM::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.PARAM)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string param = 1;
  if (this->param().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->param());
  }

  // bool log = 2;
  if (this->log() != 0) {
    total_size += 1 + 1;
  }

  // uint32 range = 3;
  if (this->range() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->range());
  }

  // uint32 highValue = 4;
  if (this->highvalue() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->highvalue());
  }

  // uint32 calibrationIndex = 5;
  if (this->calibrationindex() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->calibrationindex());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PARAM::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.PARAM)
  GOOGLE_DCHECK_NE(&from, this);
  const PARAM* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PARAM>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.PARAM)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.PARAM)
    MergeFrom(*source);
  }
}

void PARAM::MergeFrom(const PARAM& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.PARAM)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.param().size() > 0) {

    param_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.param_);
  }
  if (from.log() != 0) {
    set_log(from.log());
  }
  if (from.range() != 0) {
    set_range(from.range());
  }
  if (from.highvalue() != 0) {
    set_highvalue(from.highvalue());
  }
  if (from.calibrationindex() != 0) {
    set_calibrationindex(from.calibrationindex());
  }
}

void PARAM::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.PARAM)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void PARAM::CopyFrom(const PARAM& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.PARAM)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PARAM::IsInitialized() const {
  return true;
}

void PARAM::Swap(PARAM* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PARAM::InternalSwap(PARAM* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  param_.Swap(&other->param_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(log_, other->log_);
  swap(range_, other->range_);
  swap(highvalue_, other->highvalue_);
  swap(calibrationindex_, other->calibrationindex_);
}

::PROTOBUF_NAMESPACE_ID::Metadata PARAM::GetMetadata() const {
  return GetMetadataStatic();
}


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

void GatingHierarchy::InitAsDefaultInstance() {
  ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->tree_ = const_cast< ::pb::populationTree*>(
      ::pb::populationTree::internal_default_instance());
  ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->comp_ = const_cast< ::pb::COMP*>(
      ::pb::COMP::internal_default_instance());
  ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->trans_ = const_cast< ::pb::trans_local*>(
      ::pb::trans_local::internal_default_instance());
  ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->frame_ = const_cast< ::pb::CytoFrame*>(
      ::pb::CytoFrame::internal_default_instance());
}
class GatingHierarchy::HasBitSetters {
 public:
  static const ::pb::populationTree& tree(const GatingHierarchy* msg);
  static const ::pb::COMP& comp(const GatingHierarchy* msg);
  static const ::pb::trans_local& trans(const GatingHierarchy* msg);
  static const ::pb::CytoFrame& frame(const GatingHierarchy* msg);
};

const ::pb::populationTree&
GatingHierarchy::HasBitSetters::tree(const GatingHierarchy* msg) {
  return *msg->tree_;
}
const ::pb::COMP&
GatingHierarchy::HasBitSetters::comp(const GatingHierarchy* msg) {
  return *msg->comp_;
}
const ::pb::trans_local&
GatingHierarchy::HasBitSetters::trans(const GatingHierarchy* msg) {
  return *msg->trans_;
}
const ::pb::CytoFrame&
GatingHierarchy::HasBitSetters::frame(const GatingHierarchy* msg) {
  return *msg->frame_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int GatingHierarchy::kTreeFieldNumber;
const int GatingHierarchy::kCompFieldNumber;
const int GatingHierarchy::kIsLoadedFieldNumber;
const int GatingHierarchy::kTransFlagFieldNumber;
const int GatingHierarchy::kTransFieldNumber;
const int GatingHierarchy::kFrameFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

GatingHierarchy::GatingHierarchy()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.GatingHierarchy)
}
GatingHierarchy::GatingHierarchy(const GatingHierarchy& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      transflag_(from.transflag_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_comp()) {
    comp_ = new ::pb::COMP(*from.comp_);
  } else {
    comp_ = nullptr;
  }
  if (from.has_tree()) {
    tree_ = new ::pb::populationTree(*from.tree_);
  } else {
    tree_ = nullptr;
  }
  if (from.has_trans()) {
    trans_ = new ::pb::trans_local(*from.trans_);
  } else {
    trans_ = nullptr;
  }
  if (from.has_frame()) {
    frame_ = new ::pb::CytoFrame(*from.frame_);
  } else {
    frame_ = nullptr;
  }
  isloaded_ = from.isloaded_;
  // @@protoc_insertion_point(copy_constructor:pb.GatingHierarchy)
}

void GatingHierarchy::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GatingHierarchy_GatingSet_2eproto.base);
  ::memset(&comp_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&isloaded_) -
      reinterpret_cast<char*>(&comp_)) + sizeof(isloaded_));
}

GatingHierarchy::~GatingHierarchy() {
  // @@protoc_insertion_point(destructor:pb.GatingHierarchy)
  SharedDtor();
}

void GatingHierarchy::SharedDtor() {
  if (this != internal_default_instance()) delete comp_;
  if (this != internal_default_instance()) delete tree_;
  if (this != internal_default_instance()) delete trans_;
  if (this != internal_default_instance()) delete frame_;
}

void GatingHierarchy::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const GatingHierarchy& GatingHierarchy::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GatingHierarchy_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void GatingHierarchy::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.GatingHierarchy)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  transflag_.Clear();
  if (GetArenaNoVirtual() == nullptr && comp_ != nullptr) {
    delete comp_;
  }
  comp_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && tree_ != nullptr) {
    delete tree_;
  }
  tree_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && trans_ != nullptr) {
    delete trans_;
  }
  trans_ = nullptr;
  if (GetArenaNoVirtual() == nullptr && frame_ != nullptr) {
    delete frame_;
  }
  frame_ = nullptr;
  isloaded_ = false;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* GatingHierarchy::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .pb.COMP comp = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_comp(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.populationTree tree = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_tree(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bool isLoaded = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          isloaded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .pb.PARAM transFlag = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_transflag(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34);
        } else goto handle_unusual;
        continue;
      // .pb.trans_local trans = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_trans(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.CytoFrame frame = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(mutable_frame(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool GatingHierarchy::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.GatingHierarchy)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .pb.COMP comp = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_comp()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.populationTree tree = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_tree()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bool isLoaded = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isloaded_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.PARAM transFlag = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_transflag()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.trans_local trans = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_trans()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.CytoFrame frame = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_frame()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.GatingHierarchy)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.GatingHierarchy)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void GatingHierarchy::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.GatingHierarchy)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.COMP comp = 1;
  if (this->has_comp()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, HasBitSetters::comp(this), output);
  }

  // .pb.populationTree tree = 2;
  if (this->has_tree()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, HasBitSetters::tree(this), output);
  }

  // bool isLoaded = 3;
  if (this->isloaded() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(3, this->isloaded(), output);
  }

  // repeated .pb.PARAM transFlag = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->transflag_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      4,
      this->transflag(static_cast<int>(i)),
      output);
  }

  // .pb.trans_local trans = 5;
  if (this->has_trans()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, HasBitSetters::trans(this), output);
  }

  // .pb.CytoFrame frame = 6;
  if (this->has_frame()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, HasBitSetters::frame(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.GatingHierarchy)
}

::PROTOBUF_NAMESPACE_ID::uint8* GatingHierarchy::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.GatingHierarchy)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .pb.COMP comp = 1;
  if (this->has_comp()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, HasBitSetters::comp(this), target);
  }

  // .pb.populationTree tree = 2;
  if (this->has_tree()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, HasBitSetters::tree(this), target);
  }

  // bool isLoaded = 3;
  if (this->isloaded() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->isloaded(), target);
  }

  // repeated .pb.PARAM transFlag = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->transflag_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, this->transflag(static_cast<int>(i)), target);
  }

  // .pb.trans_local trans = 5;
  if (this->has_trans()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, HasBitSetters::trans(this), target);
  }

  // .pb.CytoFrame frame = 6;
  if (this->has_frame()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, HasBitSetters::frame(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.GatingHierarchy)
  return target;
}

size_t GatingHierarchy::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.GatingHierarchy)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .pb.PARAM transFlag = 4;
  {
    unsigned int count = static_cast<unsigned int>(this->transflag_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->transflag(static_cast<int>(i)));
    }
  }

  // .pb.COMP comp = 1;
  if (this->has_comp()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *comp_);
  }

  // .pb.populationTree tree = 2;
  if (this->has_tree()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *tree_);
  }

  // .pb.trans_local trans = 5;
  if (this->has_trans()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *trans_);
  }

  // .pb.CytoFrame frame = 6;
  if (this->has_frame()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *frame_);
  }

  // bool isLoaded = 3;
  if (this->isloaded() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GatingHierarchy::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.GatingHierarchy)
  GOOGLE_DCHECK_NE(&from, this);
  const GatingHierarchy* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GatingHierarchy>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.GatingHierarchy)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.GatingHierarchy)
    MergeFrom(*source);
  }
}

void GatingHierarchy::MergeFrom(const GatingHierarchy& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.GatingHierarchy)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  transflag_.MergeFrom(from.transflag_);
  if (from.has_comp()) {
    mutable_comp()->::pb::COMP::MergeFrom(from.comp());
  }
  if (from.has_tree()) {
    mutable_tree()->::pb::populationTree::MergeFrom(from.tree());
  }
  if (from.has_trans()) {
    mutable_trans()->::pb::trans_local::MergeFrom(from.trans());
  }
  if (from.has_frame()) {
    mutable_frame()->::pb::CytoFrame::MergeFrom(from.frame());
  }
  if (from.isloaded() != 0) {
    set_isloaded(from.isloaded());
  }
}

void GatingHierarchy::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.GatingHierarchy)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void GatingHierarchy::CopyFrom(const GatingHierarchy& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.GatingHierarchy)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GatingHierarchy::IsInitialized() const {
  return true;
}

void GatingHierarchy::Swap(GatingHierarchy* other) {
  if (other == this) return;
  InternalSwap(other);
}
void GatingHierarchy::InternalSwap(GatingHierarchy* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&transflag_)->InternalSwap(CastToBase(&other->transflag_));
  swap(comp_, other->comp_);
  swap(tree_, other->tree_);
  swap(trans_, other->trans_);
  swap(frame_, other->frame_);
  swap(isloaded_, other->isloaded_);
}

::PROTOBUF_NAMESPACE_ID::Metadata GatingHierarchy::GetMetadata() const {
  return GetMetadataStatic();
}


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

void CytoFrame::InitAsDefaultInstance() {
}
class CytoFrame::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CytoFrame::kIsH5FieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CytoFrame::CytoFrame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.CytoFrame)
}
CytoFrame::CytoFrame(const CytoFrame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  is_h5_ = from.is_h5_;
  // @@protoc_insertion_point(copy_constructor:pb.CytoFrame)
}

void CytoFrame::SharedCtor() {
  is_h5_ = false;
}

CytoFrame::~CytoFrame() {
  // @@protoc_insertion_point(destructor:pb.CytoFrame)
  SharedDtor();
}

void CytoFrame::SharedDtor() {
}

void CytoFrame::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const CytoFrame& CytoFrame::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CytoFrame_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void CytoFrame::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.CytoFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  is_h5_ = false;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* CytoFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool is_h5 = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          is_h5_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool CytoFrame::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.CytoFrame)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // bool is_h5 = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_h5_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.CytoFrame)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.CytoFrame)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void CytoFrame::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.CytoFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool is_h5 = 1;
  if (this->is_h5() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->is_h5(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.CytoFrame)
}

::PROTOBUF_NAMESPACE_ID::uint8* CytoFrame::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.CytoFrame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bool is_h5 = 1;
  if (this->is_h5() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->is_h5(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.CytoFrame)
  return target;
}

size_t CytoFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.CytoFrame)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // bool is_h5 = 1;
  if (this->is_h5() != 0) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CytoFrame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.CytoFrame)
  GOOGLE_DCHECK_NE(&from, this);
  const CytoFrame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CytoFrame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.CytoFrame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.CytoFrame)
    MergeFrom(*source);
  }
}

void CytoFrame::MergeFrom(const CytoFrame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.CytoFrame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.is_h5() != 0) {
    set_is_h5(from.is_h5());
  }
}

void CytoFrame::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.CytoFrame)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CytoFrame::CopyFrom(const CytoFrame& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.CytoFrame)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CytoFrame::IsInitialized() const {
  return true;
}

void CytoFrame::Swap(CytoFrame* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CytoFrame::InternalSwap(CytoFrame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(is_h5_, other->is_h5_);
}

::PROTOBUF_NAMESPACE_ID::Metadata CytoFrame::GetMetadata() const {
  return GetMetadataStatic();
}


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

void TRANS_TBL::InitAsDefaultInstance() {
  ::pb::_TRANS_TBL_default_instance_._instance.get_mutable()->trans_ = const_cast< ::pb::transformation*>(
      ::pb::transformation::internal_default_instance());
}
class TRANS_TBL::HasBitSetters {
 public:
  static const ::pb::transformation& trans(const TRANS_TBL* msg);
};

const ::pb::transformation&
TRANS_TBL::HasBitSetters::trans(const TRANS_TBL* msg) {
  return *msg->trans_;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TRANS_TBL::kTransAddressFieldNumber;
const int TRANS_TBL::kTransFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TRANS_TBL::TRANS_TBL()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.TRANS_TBL)
}
TRANS_TBL::TRANS_TBL(const TRANS_TBL& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_trans()) {
    trans_ = new ::pb::transformation(*from.trans_);
  } else {
    trans_ = nullptr;
  }
  trans_address_ = from.trans_address_;
  // @@protoc_insertion_point(copy_constructor:pb.TRANS_TBL)
}

void TRANS_TBL::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TRANS_TBL_GatingSet_2eproto.base);
  ::memset(&trans_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&trans_address_) -
      reinterpret_cast<char*>(&trans_)) + sizeof(trans_address_));
}

TRANS_TBL::~TRANS_TBL() {
  // @@protoc_insertion_point(destructor:pb.TRANS_TBL)
  SharedDtor();
}

void TRANS_TBL::SharedDtor() {
  if (this != internal_default_instance()) delete trans_;
}

void TRANS_TBL::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const TRANS_TBL& TRANS_TBL::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TRANS_TBL_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void TRANS_TBL::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.TRANS_TBL)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaNoVirtual() == nullptr && trans_ != nullptr) {
    delete trans_;
  }
  trans_ = nullptr;
  trans_address_ = PROTOBUF_ULONGLONG(0);
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TRANS_TBL::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // uint64 trans_address = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          trans_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .pb.transformation trans = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_trans(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TRANS_TBL::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.TRANS_TBL)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // uint64 trans_address = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &trans_address_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .pb.transformation trans = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_trans()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.TRANS_TBL)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.TRANS_TBL)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void TRANS_TBL::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.TRANS_TBL)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint64 trans_address = 1;
  if (this->trans_address() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->trans_address(), output);
  }

  // .pb.transformation trans = 2;
  if (this->has_trans()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, HasBitSetters::trans(this), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.TRANS_TBL)
}

::PROTOBUF_NAMESPACE_ID::uint8* TRANS_TBL::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.TRANS_TBL)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // uint64 trans_address = 1;
  if (this->trans_address() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->trans_address(), target);
  }

  // .pb.transformation trans = 2;
  if (this->has_trans()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, HasBitSetters::trans(this), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.TRANS_TBL)
  return target;
}

size_t TRANS_TBL::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.TRANS_TBL)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .pb.transformation trans = 2;
  if (this->has_trans()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *trans_);
  }

  // uint64 trans_address = 1;
  if (this->trans_address() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->trans_address());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TRANS_TBL::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.TRANS_TBL)
  GOOGLE_DCHECK_NE(&from, this);
  const TRANS_TBL* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TRANS_TBL>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.TRANS_TBL)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.TRANS_TBL)
    MergeFrom(*source);
  }
}

void TRANS_TBL::MergeFrom(const TRANS_TBL& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.TRANS_TBL)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_trans()) {
    mutable_trans()->::pb::transformation::MergeFrom(from.trans());
  }
  if (from.trans_address() != 0) {
    set_trans_address(from.trans_address());
  }
}

void TRANS_TBL::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.TRANS_TBL)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TRANS_TBL::CopyFrom(const TRANS_TBL& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.TRANS_TBL)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TRANS_TBL::IsInitialized() const {
  return true;
}

void TRANS_TBL::Swap(TRANS_TBL* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TRANS_TBL::InternalSwap(TRANS_TBL* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(trans_, other->trans_);
  swap(trans_address_, other->trans_address_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TRANS_TBL::GetMetadata() const {
  return GetMetadataStatic();
}


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

void GatingSet::InitAsDefaultInstance() {
}
class GatingSet::HasBitSetters {
 public:
};

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int GatingSet::kTransTblFieldNumber;
const int GatingSet::kSampleNameFieldNumber;
const int GatingSet::kGlobalBiExpTransFieldNumber;
const int GatingSet::kGlobalLinTransFieldNumber;
const int GatingSet::kGTransFieldNumber;
const int GatingSet::kGuidFieldNumber;
const int GatingSet::kCytolibVerionFieldNumber;
const int GatingSet::kPbVerionFieldNumber;
const int GatingSet::kH5VerionFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

GatingSet::GatingSet()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:pb.GatingSet)
}
GatingSet::GatingSet(const GatingSet& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      samplename_(from.samplename_),
      trans_tbl_(from.trans_tbl_),
      gtrans_(from.gtrans_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  guid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.guid().size() > 0) {
    guid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.guid_);
  }
  cytolib_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.cytolib_verion().size() > 0) {
    cytolib_verion_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cytolib_verion_);
  }
  pb_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.pb_verion().size() > 0) {
    pb_verion_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.pb_verion_);
  }
  h5_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.h5_verion().size() > 0) {
    h5_verion_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.h5_verion_);
  }
  ::memcpy(&globalbiexptrans_, &from.globalbiexptrans_,
    static_cast<size_t>(reinterpret_cast<char*>(&globallintrans_) -
    reinterpret_cast<char*>(&globalbiexptrans_)) + sizeof(globallintrans_));
  // @@protoc_insertion_point(copy_constructor:pb.GatingSet)
}

void GatingSet::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GatingSet_GatingSet_2eproto.base);
  guid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  cytolib_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  pb_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  h5_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&globalbiexptrans_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&globallintrans_) -
      reinterpret_cast<char*>(&globalbiexptrans_)) + sizeof(globallintrans_));
}

GatingSet::~GatingSet() {
  // @@protoc_insertion_point(destructor:pb.GatingSet)
  SharedDtor();
}

void GatingSet::SharedDtor() {
  guid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  cytolib_verion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  pb_verion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  h5_verion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void GatingSet::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const GatingSet& GatingSet::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GatingSet_GatingSet_2eproto.base);
  return *internal_default_instance();
}


void GatingSet::Clear() {
// @@protoc_insertion_point(message_clear_start:pb.GatingSet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  samplename_.Clear();
  trans_tbl_.Clear();
  gtrans_.Clear();
  guid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  cytolib_verion_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  pb_verion_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  h5_verion_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&globalbiexptrans_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&globallintrans_) -
      reinterpret_cast<char*>(&globalbiexptrans_)) + sizeof(globallintrans_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* GatingSet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string sampleName = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_samplename(), ptr, ctx, "pb.GatingSet.sampleName");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      // repeated .pb.TRANS_TBL trans_tbl = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_trans_tbl(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      // uint64 globalBiExpTrans = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          globalbiexptrans_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint64 globalLinTrans = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          globallintrans_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .pb.trans_local gTrans = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_gtrans(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42);
        } else goto handle_unusual;
        continue;
      // string guid = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_guid(), ptr, ctx, "pb.GatingSet.guid");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string cytolib_verion = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_cytolib_verion(), ptr, ctx, "pb.GatingSet.cytolib_verion");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string pb_verion = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_pb_verion(), ptr, ctx, "pb.GatingSet.pb_verion");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string h5_verion = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_h5_verion(), ptr, ctx, "pb.GatingSet.h5_verion");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool GatingSet::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  // @@protoc_insertion_point(parse_start:pb.GatingSet)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string sampleName = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->add_samplename()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->samplename(this->samplename_size() - 1).data(),
            static_cast<int>(this->samplename(this->samplename_size() - 1).length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.GatingSet.sampleName"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.TRANS_TBL trans_tbl = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_trans_tbl()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint64 globalBiExpTrans = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &globalbiexptrans_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // uint64 globalLinTrans = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
                 input, &globallintrans_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .pb.trans_local gTrans = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_gtrans()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string guid = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_guid()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->guid().data(), static_cast<int>(this->guid().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.GatingSet.guid"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string cytolib_verion = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_cytolib_verion()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->cytolib_verion().data(), static_cast<int>(this->cytolib_verion().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.GatingSet.cytolib_verion"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string pb_verion = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_pb_verion()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->pb_verion().data(), static_cast<int>(this->pb_verion().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.GatingSet.pb_verion"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // string h5_verion = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (74 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_h5_verion()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->h5_verion().data(), static_cast<int>(this->h5_verion().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "pb.GatingSet.h5_verion"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:pb.GatingSet)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:pb.GatingSet)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void GatingSet::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:pb.GatingSet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string sampleName = 1;
  for (int i = 0, n = this->samplename_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->samplename(i).data(), static_cast<int>(this->samplename(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.sampleName");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
      1, this->samplename(i), output);
  }

  // repeated .pb.TRANS_TBL trans_tbl = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->trans_tbl_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      2,
      this->trans_tbl(static_cast<int>(i)),
      output);
  }

  // uint64 globalBiExpTrans = 3;
  if (this->globalbiexptrans() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(3, this->globalbiexptrans(), output);
  }

  // uint64 globalLinTrans = 4;
  if (this->globallintrans() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->globallintrans(), output);
  }

  // repeated .pb.trans_local gTrans = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->gtrans_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
      5,
      this->gtrans(static_cast<int>(i)),
      output);
  }

  // string guid = 6;
  if (this->guid().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->guid().data(), static_cast<int>(this->guid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.guid");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->guid(), output);
  }

  // string cytolib_verion = 7;
  if (this->cytolib_verion().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->cytolib_verion().data(), static_cast<int>(this->cytolib_verion().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.cytolib_verion");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      7, this->cytolib_verion(), output);
  }

  // string pb_verion = 8;
  if (this->pb_verion().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->pb_verion().data(), static_cast<int>(this->pb_verion().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.pb_verion");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      8, this->pb_verion(), output);
  }

  // string h5_verion = 9;
  if (this->h5_verion().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->h5_verion().data(), static_cast<int>(this->h5_verion().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.h5_verion");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      9, this->h5_verion(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:pb.GatingSet)
}

::PROTOBUF_NAMESPACE_ID::uint8* GatingSet::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:pb.GatingSet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string sampleName = 1;
  for (int i = 0, n = this->samplename_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->samplename(i).data(), static_cast<int>(this->samplename(i).length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.sampleName");
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      WriteStringToArray(1, this->samplename(i), target);
  }

  // repeated .pb.TRANS_TBL trans_tbl = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->trans_tbl_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, this->trans_tbl(static_cast<int>(i)), target);
  }

  // uint64 globalBiExpTrans = 3;
  if (this->globalbiexptrans() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->globalbiexptrans(), target);
  }

  // uint64 globalLinTrans = 4;
  if (this->globallintrans() != 0) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->globallintrans(), target);
  }

  // repeated .pb.trans_local gTrans = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->gtrans_size()); i < n; i++) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(
        5, this->gtrans(static_cast<int>(i)), target);
  }

  // string guid = 6;
  if (this->guid().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->guid().data(), static_cast<int>(this->guid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.guid");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        6, this->guid(), target);
  }

  // string cytolib_verion = 7;
  if (this->cytolib_verion().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->cytolib_verion().data(), static_cast<int>(this->cytolib_verion().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.cytolib_verion");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        7, this->cytolib_verion(), target);
  }

  // string pb_verion = 8;
  if (this->pb_verion().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->pb_verion().data(), static_cast<int>(this->pb_verion().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.pb_verion");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        8, this->pb_verion(), target);
  }

  // string h5_verion = 9;
  if (this->h5_verion().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->h5_verion().data(), static_cast<int>(this->h5_verion().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "pb.GatingSet.h5_verion");
    target =
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
        9, this->h5_verion(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:pb.GatingSet)
  return target;
}

size_t GatingSet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:pb.GatingSet)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string sampleName = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->samplename_size());
  for (int i = 0, n = this->samplename_size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      this->samplename(i));
  }

  // repeated .pb.TRANS_TBL trans_tbl = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->trans_tbl_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->trans_tbl(static_cast<int>(i)));
    }
  }

  // repeated .pb.trans_local gTrans = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->gtrans_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->gtrans(static_cast<int>(i)));
    }
  }

  // string guid = 6;
  if (this->guid().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->guid());
  }

  // string cytolib_verion = 7;
  if (this->cytolib_verion().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->cytolib_verion());
  }

  // string pb_verion = 8;
  if (this->pb_verion().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->pb_verion());
  }

  // string h5_verion = 9;
  if (this->h5_verion().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->h5_verion());
  }

  // uint64 globalBiExpTrans = 3;
  if (this->globalbiexptrans() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->globalbiexptrans());
  }

  // uint64 globalLinTrans = 4;
  if (this->globallintrans() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->globallintrans());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GatingSet::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:pb.GatingSet)
  GOOGLE_DCHECK_NE(&from, this);
  const GatingSet* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GatingSet>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.GatingSet)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.GatingSet)
    MergeFrom(*source);
  }
}

void GatingSet::MergeFrom(const GatingSet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:pb.GatingSet)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  samplename_.MergeFrom(from.samplename_);
  trans_tbl_.MergeFrom(from.trans_tbl_);
  gtrans_.MergeFrom(from.gtrans_);
  if (from.guid().size() > 0) {

    guid_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.guid_);
  }
  if (from.cytolib_verion().size() > 0) {

    cytolib_verion_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cytolib_verion_);
  }
  if (from.pb_verion().size() > 0) {

    pb_verion_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.pb_verion_);
  }
  if (from.h5_verion().size() > 0) {

    h5_verion_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.h5_verion_);
  }
  if (from.globalbiexptrans() != 0) {
    set_globalbiexptrans(from.globalbiexptrans());
  }
  if (from.globallintrans() != 0) {
    set_globallintrans(from.globallintrans());
  }
}

void GatingSet::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:pb.GatingSet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void GatingSet::CopyFrom(const GatingSet& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:pb.GatingSet)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GatingSet::IsInitialized() const {
  return true;
}

void GatingSet::Swap(GatingSet* other) {
  if (other == this) return;
  InternalSwap(other);
}
void GatingSet::InternalSwap(GatingSet* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  samplename_.InternalSwap(CastToBase(&other->samplename_));
  CastToBase(&trans_tbl_)->InternalSwap(CastToBase(&other->trans_tbl_));
  CastToBase(&gtrans_)->InternalSwap(CastToBase(&other->gtrans_));
  guid_.Swap(&other->guid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  cytolib_verion_.Swap(&other->cytolib_verion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  pb_verion_.Swap(&other->pb_verion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  h5_verion_.Swap(&other->h5_verion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(globalbiexptrans_, other->globalbiexptrans_);
  swap(globallintrans_, other->globallintrans_);
}

::PROTOBUF_NAMESPACE_ID::Metadata GatingSet::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::pb::paramRange* Arena::CreateMaybeMessage< ::pb::paramRange >(Arena* arena) {
  return Arena::CreateInternal< ::pb::paramRange >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::rangeGate* Arena::CreateMaybeMessage< ::pb::rangeGate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::rangeGate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::paramPoly* Arena::CreateMaybeMessage< ::pb::paramPoly >(Arena* arena) {
  return Arena::CreateInternal< ::pb::paramPoly >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::polygonGate* Arena::CreateMaybeMessage< ::pb::polygonGate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::polygonGate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::coordinate* Arena::CreateMaybeMessage< ::pb::coordinate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::coordinate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::ellipseGate* Arena::CreateMaybeMessage< ::pb::ellipseGate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::ellipseGate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::BOOL_GATE_OP* Arena::CreateMaybeMessage< ::pb::BOOL_GATE_OP >(Arena* arena) {
  return Arena::CreateInternal< ::pb::BOOL_GATE_OP >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::boolGate* Arena::CreateMaybeMessage< ::pb::boolGate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::boolGate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::clusterGate* Arena::CreateMaybeMessage< ::pb::clusterGate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::clusterGate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::quadGate* Arena::CreateMaybeMessage< ::pb::quadGate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::quadGate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::gate* Arena::CreateMaybeMessage< ::pb::gate >(Arena* arena) {
  return Arena::CreateInternal< ::pb::gate >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::POPSTATS* Arena::CreateMaybeMessage< ::pb::POPSTATS >(Arena* arena) {
  return Arena::CreateInternal< ::pb::POPSTATS >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::calibrationTable* Arena::CreateMaybeMessage< ::pb::calibrationTable >(Arena* arena) {
  return Arena::CreateInternal< ::pb::calibrationTable >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::biexpTrans* Arena::CreateMaybeMessage< ::pb::biexpTrans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::biexpTrans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::fasinhTrans* Arena::CreateMaybeMessage< ::pb::fasinhTrans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::fasinhTrans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::scaleTrans* Arena::CreateMaybeMessage< ::pb::scaleTrans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::scaleTrans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::flinTrans* Arena::CreateMaybeMessage< ::pb::flinTrans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::flinTrans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::logTrans* Arena::CreateMaybeMessage< ::pb::logTrans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::logTrans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::logGML2Trans* Arena::CreateMaybeMessage< ::pb::logGML2Trans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::logGML2Trans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::logicleTrans* Arena::CreateMaybeMessage< ::pb::logicleTrans >(Arena* arena) {
  return Arena::CreateInternal< ::pb::logicleTrans >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::transformation* Arena::CreateMaybeMessage< ::pb::transformation >(Arena* arena) {
  return Arena::CreateInternal< ::pb::transformation >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::trans_pair* Arena::CreateMaybeMessage< ::pb::trans_pair >(Arena* arena) {
  return Arena::CreateInternal< ::pb::trans_pair >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::trans_local* Arena::CreateMaybeMessage< ::pb::trans_local >(Arena* arena) {
  return Arena::CreateInternal< ::pb::trans_local >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::POPINDICES* Arena::CreateMaybeMessage< ::pb::POPINDICES >(Arena* arena) {
  return Arena::CreateInternal< ::pb::POPINDICES >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::nodeProperties* Arena::CreateMaybeMessage< ::pb::nodeProperties >(Arena* arena) {
  return Arena::CreateInternal< ::pb::nodeProperties >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::treeNodes* Arena::CreateMaybeMessage< ::pb::treeNodes >(Arena* arena) {
  return Arena::CreateInternal< ::pb::treeNodes >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::populationTree* Arena::CreateMaybeMessage< ::pb::populationTree >(Arena* arena) {
  return Arena::CreateInternal< ::pb::populationTree >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::COMP* Arena::CreateMaybeMessage< ::pb::COMP >(Arena* arena) {
  return Arena::CreateInternal< ::pb::COMP >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::PARAM* Arena::CreateMaybeMessage< ::pb::PARAM >(Arena* arena) {
  return Arena::CreateInternal< ::pb::PARAM >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::GatingHierarchy* Arena::CreateMaybeMessage< ::pb::GatingHierarchy >(Arena* arena) {
  return Arena::CreateInternal< ::pb::GatingHierarchy >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::CytoFrame* Arena::CreateMaybeMessage< ::pb::CytoFrame >(Arena* arena) {
  return Arena::CreateInternal< ::pb::CytoFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::TRANS_TBL* Arena::CreateMaybeMessage< ::pb::TRANS_TBL >(Arena* arena) {
  return Arena::CreateInternal< ::pb::TRANS_TBL >(arena);
}
template<> PROTOBUF_NOINLINE ::pb::GatingSet* Arena::CreateMaybeMessage< ::pb::GatingSet >(Arena* arena) {
  return Arena::CreateInternal< ::pb::GatingSet >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>