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

#include "state_machine_config.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace fsmproto {
constexpr Action_ParamsEntry_DoNotUse::Action_ParamsEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct Action_ParamsEntry_DoNotUseDefaultTypeInternal {
  constexpr Action_ParamsEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~Action_ParamsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    Action_ParamsEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Action_ParamsEntry_DoNotUseDefaultTypeInternal _Action_ParamsEntry_DoNotUse_default_instance_;
constexpr Action::Action(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : params_()
  , type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct ActionDefaultTypeInternal {
  constexpr ActionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ActionDefaultTypeInternal() {}
  union {
    Action _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ActionDefaultTypeInternal _Action_default_instance_;
constexpr ConditionValue::ConditionValue(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : param_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , symbol_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , compare_value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct ConditionValueDefaultTypeInternal {
  constexpr ConditionValueDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ConditionValueDefaultTypeInternal() {}
  union {
    ConditionValue _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConditionValueDefaultTypeInternal _ConditionValue_default_instance_;
constexpr ConditionData::ConditionData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : values_(){}
struct ConditionDataDefaultTypeInternal {
  constexpr ConditionDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ConditionDataDefaultTypeInternal() {}
  union {
    ConditionData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConditionDataDefaultTypeInternal _ConditionData_default_instance_;
constexpr Transition::Transition(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : condition_()
  , before_switch_actions_()
  , after_switch_actions_()
  , src_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , dst_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , event_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct TransitionDefaultTypeInternal {
  constexpr TransitionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TransitionDefaultTypeInternal() {}
  union {
    Transition _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TransitionDefaultTypeInternal _Transition_default_instance_;
constexpr State::State(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : entry_()
  , idle_()
  , exit_()
  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , fsm_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , state_delegate_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct StateDefaultTypeInternal {
  constexpr StateDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~StateDefaultTypeInternal() {}
  union {
    State _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StateDefaultTypeInternal _State_default_instance_;
constexpr Param::Param(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , default_value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct ParamDefaultTypeInternal {
  constexpr ParamDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ParamDefaultTypeInternal() {}
  union {
    Param _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParamDefaultTypeInternal _Param_default_instance_;
constexpr StateMachine_ParamsEntry_DoNotUse::StateMachine_ParamsEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct StateMachine_ParamsEntry_DoNotUseDefaultTypeInternal {
  constexpr StateMachine_ParamsEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~StateMachine_ParamsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    StateMachine_ParamsEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StateMachine_ParamsEntry_DoNotUseDefaultTypeInternal _StateMachine_ParamsEntry_DoNotUse_default_instance_;
constexpr StateMachine::StateMachine(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : params_()
  , states_()
  , transitions_()
  , init_state_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , machine_type_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct StateMachineDefaultTypeInternal {
  constexpr StateMachineDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~StateMachineDefaultTypeInternal() {}
  union {
    StateMachine _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StateMachineDefaultTypeInternal _StateMachine_default_instance_;
}  // namespace fsmproto
namespace fsmproto {

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

Action_ParamsEntry_DoNotUse::Action_ParamsEntry_DoNotUse() {}
Action_ParamsEntry_DoNotUse::Action_ParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void Action_ParamsEntry_DoNotUse::MergeFrom(const Action_ParamsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

class Action::_Internal {
 public:
};

Action::Action(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  params_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.Action)
}
Action::Action(const Action& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  params_.MergeFrom(from.params_);
  type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_type().empty()) {
    type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:fsmproto.Action)
}

void Action::SharedCtor() {
type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Action::~Action() {
  // @@protoc_insertion_point(destructor:fsmproto.Action)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Action::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Action::ArenaDtor(void* object) {
  Action* _this = reinterpret_cast< Action* >(object);
  (void)_this;
}
void Action::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Action::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  params_.Clear();
  type_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* Action::_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 type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_type();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // map<string, string> params = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&params_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Action::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.Action)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string type = 1;
  if (this->type().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_type().data(), static_cast<int>(this->_internal_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.Action.type");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_type(), target);
  }

  // map<string, string> params = 2;
  if (!this->_internal_params().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "fsmproto.Action.ParamsEntry.key");
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), static_cast<int>(p->second.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "fsmproto.Action.ParamsEntry.value");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_params().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_params().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
          it = this->_internal_params().begin();
          it != this->_internal_params().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = Action_ParamsEntry_DoNotUse::Funcs::InternalSerialize(2, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
          it = this->_internal_params().begin();
          it != this->_internal_params().end(); ++it) {
        target = Action_ParamsEntry_DoNotUse::Funcs::InternalSerialize(2, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.Action)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // map<string, string> params = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_params_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
      it = this->_internal_params().begin();
      it != this->_internal_params().end(); ++it) {
    total_size += Action_ParamsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Action::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Action*>(
      &from));
}

void Action::MergeFrom(const Action& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.Action)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  params_.MergeFrom(from.params_);
  if (from.type().size() > 0) {
    _internal_set_type(from._internal_type());
  }
}

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

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

void Action::InternalSwap(Action* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  params_.Swap(&other->params_);
  type_.Swap(&other->type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string Action::GetTypeName() const {
  return "fsmproto.Action";
}


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

class ConditionValue::_Internal {
 public:
};

ConditionValue::ConditionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.ConditionValue)
}
ConditionValue::ConditionValue(const ConditionValue& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  param_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_param_name().empty()) {
    param_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_param_name(), 
      GetArena());
  }
  symbol_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_symbol().empty()) {
    symbol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_symbol(), 
      GetArena());
  }
  compare_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_compare_value().empty()) {
    compare_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_compare_value(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:fsmproto.ConditionValue)
}

void ConditionValue::SharedCtor() {
param_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
symbol_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
compare_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

ConditionValue::~ConditionValue() {
  // @@protoc_insertion_point(destructor:fsmproto.ConditionValue)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void ConditionValue::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  param_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  symbol_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  compare_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ConditionValue::ArenaDtor(void* object) {
  ConditionValue* _this = reinterpret_cast< ConditionValue* >(object);
  (void)_this;
}
void ConditionValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ConditionValue::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  param_name_.ClearToEmpty();
  symbol_.ClearToEmpty();
  compare_value_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* ConditionValue::_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_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_param_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string symbol = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_symbol();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string compare_value = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_compare_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ConditionValue::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.ConditionValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string param_name = 1;
  if (this->param_name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_param_name().data(), static_cast<int>(this->_internal_param_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.ConditionValue.param_name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_param_name(), target);
  }

  // string symbol = 2;
  if (this->symbol().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_symbol().data(), static_cast<int>(this->_internal_symbol().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.ConditionValue.symbol");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_symbol(), target);
  }

  // string compare_value = 3;
  if (this->compare_value().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_compare_value().data(), static_cast<int>(this->_internal_compare_value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.ConditionValue.compare_value");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_compare_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.ConditionValue)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ConditionValue::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConditionValue*>(
      &from));
}

void ConditionValue::MergeFrom(const ConditionValue& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.ConditionValue)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.param_name().size() > 0) {
    _internal_set_param_name(from._internal_param_name());
  }
  if (from.symbol().size() > 0) {
    _internal_set_symbol(from._internal_symbol());
  }
  if (from.compare_value().size() > 0) {
    _internal_set_compare_value(from._internal_compare_value());
  }
}

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

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

void ConditionValue::InternalSwap(ConditionValue* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  param_name_.Swap(&other->param_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  symbol_.Swap(&other->symbol_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  compare_value_.Swap(&other->compare_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string ConditionValue::GetTypeName() const {
  return "fsmproto.ConditionValue";
}


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

class ConditionData::_Internal {
 public:
};

ConditionData::ConditionData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  values_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.ConditionData)
}
ConditionData::ConditionData(const ConditionData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      values_(from.values_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:fsmproto.ConditionData)
}

void ConditionData::SharedCtor() {
}

ConditionData::~ConditionData() {
  // @@protoc_insertion_point(destructor:fsmproto.ConditionData)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void ConditionData::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void ConditionData::ArenaDtor(void* object) {
  ConditionData* _this = reinterpret_cast< ConditionData* >(object);
  (void)_this;
}
void ConditionData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ConditionData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  values_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* ConditionData::_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 .fsmproto.ConditionValue values = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* ConditionData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.ConditionData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .fsmproto.ConditionValue values = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_values_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_values(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.ConditionData)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .fsmproto.ConditionValue values = 1;
  total_size += 1UL * this->_internal_values_size();
  for (const auto& msg : this->values_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ConditionData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConditionData*>(
      &from));
}

void ConditionData::MergeFrom(const ConditionData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.ConditionData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  values_.MergeFrom(from.values_);
}

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

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

void ConditionData::InternalSwap(ConditionData* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  values_.InternalSwap(&other->values_);
}

std::string ConditionData::GetTypeName() const {
  return "fsmproto.ConditionData";
}


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

class Transition::_Internal {
 public:
};

Transition::Transition(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  condition_(arena),
  before_switch_actions_(arena),
  after_switch_actions_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.Transition)
}
Transition::Transition(const Transition& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      condition_(from.condition_),
      before_switch_actions_(from.before_switch_actions_),
      after_switch_actions_(from.after_switch_actions_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  src_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_src().empty()) {
    src_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_src(), 
      GetArena());
  }
  dst_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_dst().empty()) {
    dst_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_dst(), 
      GetArena());
  }
  event_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_event().empty()) {
    event_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_event(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:fsmproto.Transition)
}

void Transition::SharedCtor() {
src_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
dst_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
event_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Transition::~Transition() {
  // @@protoc_insertion_point(destructor:fsmproto.Transition)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Transition::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  src_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  dst_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  event_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Transition::ArenaDtor(void* object) {
  Transition* _this = reinterpret_cast< Transition* >(object);
  (void)_this;
}
void Transition::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Transition::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  condition_.Clear();
  before_switch_actions_.Clear();
  after_switch_actions_.Clear();
  src_.ClearToEmpty();
  dst_.ClearToEmpty();
  event_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* Transition::_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 src = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_src();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string dst = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_dst();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string event = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_event();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.ConditionData condition = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_condition(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.Action before_switch_actions = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_before_switch_actions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.Action after_switch_actions = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_after_switch_actions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Transition::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.Transition)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string src = 1;
  if (this->src().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_src().data(), static_cast<int>(this->_internal_src().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.Transition.src");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_src(), target);
  }

  // string dst = 2;
  if (this->dst().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_dst().data(), static_cast<int>(this->_internal_dst().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.Transition.dst");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_dst(), target);
  }

  // string event = 3;
  if (this->event().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_event().data(), static_cast<int>(this->_internal_event().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.Transition.event");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_event(), target);
  }

  // repeated .fsmproto.ConditionData condition = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_condition_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_condition(i), target, stream);
  }

  // repeated .fsmproto.Action before_switch_actions = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_before_switch_actions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_before_switch_actions(i), target, stream);
  }

  // repeated .fsmproto.Action after_switch_actions = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_after_switch_actions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_after_switch_actions(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.Transition)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .fsmproto.ConditionData condition = 4;
  total_size += 1UL * this->_internal_condition_size();
  for (const auto& msg : this->condition_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .fsmproto.Action before_switch_actions = 5;
  total_size += 1UL * this->_internal_before_switch_actions_size();
  for (const auto& msg : this->before_switch_actions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .fsmproto.Action after_switch_actions = 6;
  total_size += 1UL * this->_internal_after_switch_actions_size();
  for (const auto& msg : this->after_switch_actions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Transition::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Transition*>(
      &from));
}

void Transition::MergeFrom(const Transition& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.Transition)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  condition_.MergeFrom(from.condition_);
  before_switch_actions_.MergeFrom(from.before_switch_actions_);
  after_switch_actions_.MergeFrom(from.after_switch_actions_);
  if (from.src().size() > 0) {
    _internal_set_src(from._internal_src());
  }
  if (from.dst().size() > 0) {
    _internal_set_dst(from._internal_dst());
  }
  if (from.event().size() > 0) {
    _internal_set_event(from._internal_event());
  }
}

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

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

void Transition::InternalSwap(Transition* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  condition_.InternalSwap(&other->condition_);
  before_switch_actions_.InternalSwap(&other->before_switch_actions_);
  after_switch_actions_.InternalSwap(&other->after_switch_actions_);
  src_.Swap(&other->src_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  dst_.Swap(&other->dst_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  event_.Swap(&other->event_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string Transition::GetTypeName() const {
  return "fsmproto.Transition";
}


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

class State::_Internal {
 public:
};

State::State(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  entry_(arena),
  idle_(arena),
  exit_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.State)
}
State::State(const State& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      entry_(from.entry_),
      idle_(from.idle_),
      exit_(from.exit_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_name().empty()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArena());
  }
  fsm_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_fsm_name().empty()) {
    fsm_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fsm_name(), 
      GetArena());
  }
  state_delegate_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_state_delegate_key().empty()) {
    state_delegate_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_state_delegate_key(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:fsmproto.State)
}

void State::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
fsm_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
state_delegate_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

State::~State() {
  // @@protoc_insertion_point(destructor:fsmproto.State)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void State::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  fsm_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  state_delegate_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void State::ArenaDtor(void* object) {
  State* _this = reinterpret_cast< State* >(object);
  (void)_this;
}
void State::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void State::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  entry_.Clear();
  idle_.Clear();
  exit_.Clear();
  name_.ClearToEmpty();
  fsm_name_.ClearToEmpty();
  state_delegate_key_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* State::_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)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.Action entry = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_entry(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.Action idle = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_idle(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.Action exit = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_exit(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // string fsm_name = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_fsm_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string state_delegate_key = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_state_delegate_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* State::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.State)
  ::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->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.State.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  // repeated .fsmproto.Action entry = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_entry_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_entry(i), target, stream);
  }

  // repeated .fsmproto.Action idle = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_idle_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_idle(i), target, stream);
  }

  // repeated .fsmproto.Action exit = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_exit_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_exit(i), target, stream);
  }

  // string fsm_name = 5;
  if (this->fsm_name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_fsm_name().data(), static_cast<int>(this->_internal_fsm_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.State.fsm_name");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_fsm_name(), target);
  }

  // string state_delegate_key = 6;
  if (this->state_delegate_key().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_state_delegate_key().data(), static_cast<int>(this->_internal_state_delegate_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.State.state_delegate_key");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_state_delegate_key(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.State)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .fsmproto.Action entry = 2;
  total_size += 1UL * this->_internal_entry_size();
  for (const auto& msg : this->entry_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .fsmproto.Action idle = 3;
  total_size += 1UL * this->_internal_idle_size();
  for (const auto& msg : this->idle_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .fsmproto.Action exit = 4;
  total_size += 1UL * this->_internal_exit_size();
  for (const auto& msg : this->exit_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void State::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const State*>(
      &from));
}

void State::MergeFrom(const State& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.State)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  entry_.MergeFrom(from.entry_);
  idle_.MergeFrom(from.idle_);
  exit_.MergeFrom(from.exit_);
  if (from.name().size() > 0) {
    _internal_set_name(from._internal_name());
  }
  if (from.fsm_name().size() > 0) {
    _internal_set_fsm_name(from._internal_fsm_name());
  }
  if (from.state_delegate_key().size() > 0) {
    _internal_set_state_delegate_key(from._internal_state_delegate_key());
  }
}

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

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

void State::InternalSwap(State* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  entry_.InternalSwap(&other->entry_);
  idle_.InternalSwap(&other->idle_);
  exit_.InternalSwap(&other->exit_);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  fsm_name_.Swap(&other->fsm_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  state_delegate_key_.Swap(&other->state_delegate_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string State::GetTypeName() const {
  return "fsmproto.State";
}


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

class Param::_Internal {
 public:
};

Param::Param(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.Param)
}
Param::Param(const Param& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_type().empty()) {
    type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_type(), 
      GetArena());
  }
  default_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_default_value().empty()) {
    default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_default_value(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:fsmproto.Param)
}

void Param::SharedCtor() {
type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
default_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Param::~Param() {
  // @@protoc_insertion_point(destructor:fsmproto.Param)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void Param::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  default_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Param::ArenaDtor(void* object) {
  Param* _this = reinterpret_cast< Param* >(object);
  (void)_this;
}
void Param::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Param::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  type_.ClearToEmpty();
  default_value_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

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 type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_type();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string default_value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_default_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Param::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.Param)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string type = 1;
  if (this->type().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_type().data(), static_cast<int>(this->_internal_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.Param.type");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_type(), target);
  }

  // string default_value = 2;
  if (this->default_value().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_default_value().data(), static_cast<int>(this->_internal_default_value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.Param.default_value");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_default_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.Param)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Param::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Param*>(
      &from));
}

void Param::MergeFrom(const Param& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.Param)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.type().size() > 0) {
    _internal_set_type(from._internal_type());
  }
  if (from.default_value().size() > 0) {
    _internal_set_default_value(from._internal_default_value());
  }
}

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

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

void Param::InternalSwap(Param* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  type_.Swap(&other->type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  default_value_.Swap(&other->default_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string Param::GetTypeName() const {
  return "fsmproto.Param";
}


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

StateMachine_ParamsEntry_DoNotUse::StateMachine_ParamsEntry_DoNotUse() {}
StateMachine_ParamsEntry_DoNotUse::StateMachine_ParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void StateMachine_ParamsEntry_DoNotUse::MergeFrom(const StateMachine_ParamsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}

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

class StateMachine::_Internal {
 public:
};

StateMachine::StateMachine(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  params_(arena),
  states_(arena),
  transitions_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:fsmproto.StateMachine)
}
StateMachine::StateMachine(const StateMachine& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      states_(from.states_),
      transitions_(from.transitions_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  params_.MergeFrom(from.params_);
  init_state_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_init_state_name().empty()) {
    init_state_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_init_state_name(), 
      GetArena());
  }
  machine_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_machine_type().empty()) {
    machine_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_machine_type(), 
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:fsmproto.StateMachine)
}

void StateMachine::SharedCtor() {
init_state_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
machine_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

StateMachine::~StateMachine() {
  // @@protoc_insertion_point(destructor:fsmproto.StateMachine)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void StateMachine::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  init_state_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  machine_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void StateMachine::ArenaDtor(void* object) {
  StateMachine* _this = reinterpret_cast< StateMachine* >(object);
  (void)_this;
}
void StateMachine::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void StateMachine::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

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

  params_.Clear();
  states_.Clear();
  transitions_.Clear();
  init_state_name_.ClearToEmpty();
  machine_type_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* StateMachine::_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 init_state_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_init_state_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string machine_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_machine_type();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // map<string, .fsmproto.Param> params = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&params_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.State states = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_states(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .fsmproto.Transition transitions = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_transitions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(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_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* StateMachine::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:fsmproto.StateMachine)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string init_state_name = 1;
  if (this->init_state_name().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_init_state_name().data(), static_cast<int>(this->_internal_init_state_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.StateMachine.init_state_name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_init_state_name(), target);
  }

  // string machine_type = 2;
  if (this->machine_type().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_machine_type().data(), static_cast<int>(this->_internal_machine_type().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "fsmproto.StateMachine.machine_type");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_machine_type(), target);
  }

  // map<string, .fsmproto.Param> params = 3;
  if (!this->_internal_params().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), static_cast<int>(p->first.length()),
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
          "fsmproto.StateMachine.ParamsEntry.key");
      }
    };

    if (stream->IsSerializationDeterministic() &&
        this->_internal_params().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_params().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >::const_iterator
          it = this->_internal_params().begin();
          it != this->_internal_params().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = StateMachine_ParamsEntry_DoNotUse::Funcs::InternalSerialize(3, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >::const_iterator
          it = this->_internal_params().begin();
          it != this->_internal_params().end(); ++it) {
        target = StateMachine_ParamsEntry_DoNotUse::Funcs::InternalSerialize(3, it->first, it->second, target, stream);
        Utf8Check::Check(&(*it));
      }
    }
  }

  // repeated .fsmproto.State states = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_states_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_states(i), target, stream);
  }

  // repeated .fsmproto.Transition transitions = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_transitions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_transitions(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:fsmproto.StateMachine)
  return target;
}

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

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // map<string, .fsmproto.Param> params = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_params_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >::const_iterator
      it = this->_internal_params().begin();
      it != this->_internal_params().end(); ++it) {
    total_size += StateMachine_ParamsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // repeated .fsmproto.State states = 4;
  total_size += 1UL * this->_internal_states_size();
  for (const auto& msg : this->states_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .fsmproto.Transition transitions = 5;
  total_size += 1UL * this->_internal_transitions_size();
  for (const auto& msg : this->transitions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void StateMachine::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const StateMachine*>(
      &from));
}

void StateMachine::MergeFrom(const StateMachine& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:fsmproto.StateMachine)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  params_.MergeFrom(from.params_);
  states_.MergeFrom(from.states_);
  transitions_.MergeFrom(from.transitions_);
  if (from.init_state_name().size() > 0) {
    _internal_set_init_state_name(from._internal_init_state_name());
  }
  if (from.machine_type().size() > 0) {
    _internal_set_machine_type(from._internal_machine_type());
  }
}

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

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

void StateMachine::InternalSwap(StateMachine* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  params_.Swap(&other->params_);
  states_.InternalSwap(&other->states_);
  transitions_.InternalSwap(&other->transitions_);
  init_state_name_.Swap(&other->init_state_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  machine_type_.Swap(&other->machine_type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

std::string StateMachine::GetTypeName() const {
  return "fsmproto.StateMachine";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace fsmproto
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::fsmproto::Action_ParamsEntry_DoNotUse* Arena::CreateMaybeMessage< ::fsmproto::Action_ParamsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::Action_ParamsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::Action* Arena::CreateMaybeMessage< ::fsmproto::Action >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::Action >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::ConditionValue* Arena::CreateMaybeMessage< ::fsmproto::ConditionValue >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::ConditionValue >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::ConditionData* Arena::CreateMaybeMessage< ::fsmproto::ConditionData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::ConditionData >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::Transition* Arena::CreateMaybeMessage< ::fsmproto::Transition >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::Transition >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::State* Arena::CreateMaybeMessage< ::fsmproto::State >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::State >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::Param* Arena::CreateMaybeMessage< ::fsmproto::Param >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::Param >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::StateMachine_ParamsEntry_DoNotUse* Arena::CreateMaybeMessage< ::fsmproto::StateMachine_ParamsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::StateMachine_ParamsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::fsmproto::StateMachine* Arena::CreateMaybeMessage< ::fsmproto::StateMachine >(Arena* arena) {
  return Arena::CreateMessageInternal< ::fsmproto::StateMachine >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>