text:
extern PROTOBUF_INTERNAL_EXPORT_control_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ApplyForceToParams_control_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DrawMarkerAtParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DrawMarkerTrajParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_control_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_GetEpisodeDataParams_control_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HighlightParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LoadLevelParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RemoveHighlightParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SetEpisodeParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_control_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SetIndividualPoseParams_control_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_viz_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SetTaskParams_viz_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_control_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StartLoggingParams_control_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_control_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StartSimulationParams_control_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_control_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_StopSimulationParams_control_2eproto;
namespace sl_pb {
class KRAmevaEventDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<KRAmevaEvent> _instance;
} _KRAmevaEvent_default_instance_;
class KRAmevaResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<KRAmevaResponse> _instance;
} _KRAmevaResponse_default_instance_;
}  // namespace sl_pb
static void InitDefaultsscc_info_KRAmevaEvent_ameva_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::sl_pb::_KRAmevaEvent_default_instance_;
    new (ptr) ::sl_pb::KRAmevaEvent();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::sl_pb::KRAmevaEvent::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<13> scc_info_KRAmevaEvent_ameva_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 13, 0, InitDefaultsscc_info_KRAmevaEvent_ameva_2eproto}, {
      &scc_info_SetTaskParams_viz_2eproto.base,
      &scc_info_SetEpisodeParams_viz_2eproto.base,
      &scc_info_DrawMarkerAtParams_viz_2eproto.base,
      &scc_info_DrawMarkerTrajParams_viz_2eproto.base,
      &scc_info_LoadLevelParams_viz_2eproto.base,
      &scc_info_StartLoggingParams_control_2eproto.base,
      &scc_info_GetEpisodeDataParams_control_2eproto.base,
      &scc_info_StartSimulationParams_control_2eproto.base,
      &scc_info_StopSimulationParams_control_2eproto.base,
      &scc_info_SetIndividualPoseParams_control_2eproto.base,
      &scc_info_ApplyForceToParams_control_2eproto.base,
      &scc_info_HighlightParams_viz_2eproto.base,
      &scc_info_RemoveHighlightParams_viz_2eproto.base,}};

static void InitDefaultsscc_info_KRAmevaResponse_ameva_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::sl_pb::_KRAmevaResponse_default_instance_;
    new (ptr) ::sl_pb::KRAmevaResponse();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::sl_pb::KRAmevaResponse::InitAsDefaultInstance();
}

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

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_ameva_2eproto[2];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_ameva_2eproto[2];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_ameva_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_ameva_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, functocall_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, settaskparam_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, setepisodeparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, drawmarkeratparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, drawmarkertrajparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, loadlevelparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, startloggingparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, getepisodedataparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, startsimulationparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, stopsimulationparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, setindividualposeparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, applyforcetoparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, highlightparams_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaEvent, removehighlightparams_),
  13,
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  11,
  12,
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, type_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, text_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, filename_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, filedata_),
  PROTOBUF_FIELD_OFFSET(::sl_pb::KRAmevaResponse, datalength_),
  4,
  0,
  1,
  2,
  3,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 19, sizeof(::sl_pb::KRAmevaEvent)},
  { 33, 43, sizeof(::sl_pb::KRAmevaResponse)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::sl_pb::_KRAmevaEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::sl_pb::_KRAmevaResponse_default_instance_),
};

const char descriptor_table_protodef_ameva_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\013ameva.proto\022\005sl_pb\032\tviz.proto\032\rcontrol"
  ".proto\"\272\010\n\014KRAmevaEvent\0222\n\nfuncToCall\030\001 "
  "\002(\0162\036.sl_pb.KRAmevaEvent.FuncToCall\022*\n\014s"
  "etTaskParam\030\002 \001(\0132\024.sl_pb.SetTaskParams\022"
  "1\n\020setEpisodeParams\030\003 \001(\0132\027.sl_pb.SetEpi"
  "sodeParams\0225\n\022drawMarkerAtParams\030\004 \001(\0132\031"
  ".sl_pb.DrawMarkerAtParams\0229\n\024drawMarkerT"
  "rajParams\030\005 \001(\0132\033.sl_pb.DrawMarkerTrajPa"
  "rams\022/\n\017loadLevelParams\030\006 \001(\0132\026.sl_pb.Lo"
  "adLevelParams\0225\n\022startLoggingParams\030\007 \001("
  "\0132\031.sl_pb.StartLoggingParams\0229\n\024getEpiso"
  "deDataParams\030\010 \001(\0132\033.sl_pb.GetEpisodeDat"
  "aParams\022;\n\025startSimulationParams\030\t \001(\0132\034"
  ".sl_pb.StartSimulationParams\0229\n\024stopSimu"
  "lationParams\030\n \001(\0132\033.sl_pb.StopSimulatio"
  "nParams\022\?\n\027setIndividualPoseParams\030\013 \001(\013"
  "2\036.sl_pb.SetIndividualPoseParams\0225\n\022appl"
  "yForceToParams\030\014 \001(\0132\031.sl_pb.ApplyForceT"
  "oParams\022/\n\017highlightParams\030\r \001(\0132\026.sl_pb"
  ".HighlightParams\022;\n\025removeHighlightParam"
  "s\030\016 \001(\0132\034.sl_pb.RemoveHighlightParams\"\243\002"
  "\n\nFuncToCall\022\013\n\007SetTask\020\001\022\016\n\nSetEpisode\020"
  "\002\022\020\n\014DrawMarkerAt\020\003\022\022\n\016DrawMarkerTraj\020\004\022"
  "\r\n\tLoadLevel\020\005\022\020\n\014StartLogging\020\006\022\017\n\013Stop"
  "Logging\020\007\022\022\n\016GetEpisodeData\020\010\022\023\n\017StartSi"
  "mulation\020\t\022\022\n\016StopSimulation\020\n\022\025\n\021SetInd"
  "ividualPose\020\013\022\020\n\014ApplyForceTo\020\014\022\r\n\tHighl"
  "ight\020\r\022\023\n\017RemoveHighlight\020\016\022\026\n\022RemoveAll"
  "Highlight\020\017\"\324\001\n\017KRAmevaResponse\0221\n\004type\030"
  "\001 \002(\0162#.sl_pb.KRAmevaResponse.ResponseTy"
  "pe\022\014\n\004text\030\002 \001(\t\022\020\n\010fileName\030\003 \001(\t\022\020\n\010fi"
  "leData\030\004 \001(\014\022\022\n\ndataLength\030\005 \001(\005\"H\n\014Resp"
  "onseType\022\010\n\004Text\020\001\022\020\n\014FileCreation\020\002\022\014\n\010"
  "FileData\020\003\022\016\n\nFileFinish\020\004"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_ameva_2eproto_deps[2] = {
  &::descriptor_table_control_2eproto,
  &::descriptor_table_viz_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_ameva_2eproto_sccs[2] = {
  &scc_info_KRAmevaEvent_ameva_2eproto.base,
  &scc_info_KRAmevaResponse_ameva_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_ameva_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ameva_2eproto = {
  false, false, descriptor_table_protodef_ameva_2eproto, "ameva.proto", 1346,
  &descriptor_table_ameva_2eproto_once, descriptor_table_ameva_2eproto_sccs, descriptor_table_ameva_2eproto_deps, 2, 2,
  schemas, file_default_instances, TableStruct_ameva_2eproto::offsets,
  file_level_metadata_ameva_2eproto, 2, file_level_enum_descriptors_ameva_2eproto, file_level_service_descriptors_ameva_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_ameva_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_ameva_2eproto)), true);
namespace sl_pb {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KRAmevaEvent_FuncToCall_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ameva_2eproto);
  return file_level_enum_descriptors_ameva_2eproto[0];
}
bool KRAmevaEvent_FuncToCall_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::SetTask;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::SetEpisode;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::DrawMarkerAt;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::DrawMarkerTraj;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::LoadLevel;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::StartLogging;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::StopLogging;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::GetEpisodeData;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::StartSimulation;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::StopSimulation;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::SetIndividualPose;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::ApplyForceTo;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::Highlight;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::RemoveHighlight;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::RemoveAllHighlight;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::FuncToCall_MIN;
constexpr KRAmevaEvent_FuncToCall KRAmevaEvent::FuncToCall_MAX;
constexpr int KRAmevaEvent::FuncToCall_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KRAmevaResponse_ResponseType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ameva_2eproto);
  return file_level_enum_descriptors_ameva_2eproto[1];
}
bool KRAmevaResponse_ResponseType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr KRAmevaResponse_ResponseType KRAmevaResponse::Text;
constexpr KRAmevaResponse_ResponseType KRAmevaResponse::FileCreation;
constexpr KRAmevaResponse_ResponseType KRAmevaResponse::FileData;
constexpr KRAmevaResponse_ResponseType KRAmevaResponse::FileFinish;
constexpr KRAmevaResponse_ResponseType KRAmevaResponse::ResponseType_MIN;
constexpr KRAmevaResponse_ResponseType KRAmevaResponse::ResponseType_MAX;
constexpr int KRAmevaResponse::ResponseType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)

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

void KRAmevaEvent::InitAsDefaultInstance() {
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->settaskparam_ = const_cast< ::sl_pb::SetTaskParams*>(
      ::sl_pb::SetTaskParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->setepisodeparams_ = const_cast< ::sl_pb::SetEpisodeParams*>(
      ::sl_pb::SetEpisodeParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->drawmarkeratparams_ = const_cast< ::sl_pb::DrawMarkerAtParams*>(
      ::sl_pb::DrawMarkerAtParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->drawmarkertrajparams_ = const_cast< ::sl_pb::DrawMarkerTrajParams*>(
      ::sl_pb::DrawMarkerTrajParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->loadlevelparams_ = const_cast< ::sl_pb::LoadLevelParams*>(
      ::sl_pb::LoadLevelParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->startloggingparams_ = const_cast< ::sl_pb::StartLoggingParams*>(
      ::sl_pb::StartLoggingParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->getepisodedataparams_ = const_cast< ::sl_pb::GetEpisodeDataParams*>(
      ::sl_pb::GetEpisodeDataParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->startsimulationparams_ = const_cast< ::sl_pb::StartSimulationParams*>(
      ::sl_pb::StartSimulationParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->stopsimulationparams_ = const_cast< ::sl_pb::StopSimulationParams*>(
      ::sl_pb::StopSimulationParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->setindividualposeparams_ = const_cast< ::sl_pb::SetIndividualPoseParams*>(
      ::sl_pb::SetIndividualPoseParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->applyforcetoparams_ = const_cast< ::sl_pb::ApplyForceToParams*>(
      ::sl_pb::ApplyForceToParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->highlightparams_ = const_cast< ::sl_pb::HighlightParams*>(
      ::sl_pb::HighlightParams::internal_default_instance());
  ::sl_pb::_KRAmevaEvent_default_instance_._instance.get_mutable()->removehighlightparams_ = const_cast< ::sl_pb::RemoveHighlightParams*>(
      ::sl_pb::RemoveHighlightParams::internal_default_instance());
}
class KRAmevaEvent::_Internal {
 public:
  using HasBits = decltype(std::declval<KRAmevaEvent>()._has_bits_);
  static void set_has_functocall(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static const ::sl_pb::SetTaskParams& settaskparam(const KRAmevaEvent* msg);
  static void set_has_settaskparam(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::sl_pb::SetEpisodeParams& setepisodeparams(const KRAmevaEvent* msg);
  static void set_has_setepisodeparams(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::sl_pb::DrawMarkerAtParams& drawmarkeratparams(const KRAmevaEvent* msg);
  static void set_has_drawmarkeratparams(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::sl_pb::DrawMarkerTrajParams& drawmarkertrajparams(const KRAmevaEvent* msg);
  static void set_has_drawmarkertrajparams(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::sl_pb::LoadLevelParams& loadlevelparams(const KRAmevaEvent* msg);
  static void set_has_loadlevelparams(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::sl_pb::StartLoggingParams& startloggingparams(const KRAmevaEvent* msg);
  static void set_has_startloggingparams(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::sl_pb::GetEpisodeDataParams& getepisodedataparams(const KRAmevaEvent* msg);
  static void set_has_getepisodedataparams(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::sl_pb::StartSimulationParams& startsimulationparams(const KRAmevaEvent* msg);
  static void set_has_startsimulationparams(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static const ::sl_pb::StopSimulationParams& stopsimulationparams(const KRAmevaEvent* msg);
  static void set_has_stopsimulationparams(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static const ::sl_pb::SetIndividualPoseParams& setindividualposeparams(const KRAmevaEvent* msg);
  static void set_has_setindividualposeparams(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static const ::sl_pb::ApplyForceToParams& applyforcetoparams(const KRAmevaEvent* msg);
  static void set_has_applyforcetoparams(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static const ::sl_pb::HighlightParams& highlightparams(const KRAmevaEvent* msg);
  static void set_has_highlightparams(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static const ::sl_pb::RemoveHighlightParams& removehighlightparams(const KRAmevaEvent* msg);
  static void set_has_removehighlightparams(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00002000) ^ 0x00002000) != 0;
  }
};

const ::sl_pb::SetTaskParams&
KRAmevaEvent::_Internal::settaskparam(const KRAmevaEvent* msg) {
  return *msg->settaskparam_;
}
const ::sl_pb::SetEpisodeParams&
KRAmevaEvent::_Internal::setepisodeparams(const KRAmevaEvent* msg) {
  return *msg->setepisodeparams_;
}
const ::sl_pb::DrawMarkerAtParams&
KRAmevaEvent::_Internal::drawmarkeratparams(const KRAmevaEvent* msg) {
  return *msg->drawmarkeratparams_;
}
const ::sl_pb::DrawMarkerTrajParams&
KRAmevaEvent::_Internal::drawmarkertrajparams(const KRAmevaEvent* msg) {
  return *msg->drawmarkertrajparams_;
}
const ::sl_pb::LoadLevelParams&
KRAmevaEvent::_Internal::loadlevelparams(const KRAmevaEvent* msg) {
  return *msg->loadlevelparams_;
}
const ::sl_pb::StartLoggingParams&
KRAmevaEvent::_Internal::startloggingparams(const KRAmevaEvent* msg) {
  return *msg->startloggingparams_;
}
const ::sl_pb::GetEpisodeDataParams&
KRAmevaEvent::_Internal::getepisodedataparams(const KRAmevaEvent* msg) {
  return *msg->getepisodedataparams_;
}
const ::sl_pb::StartSimulationParams&
KRAmevaEvent::_Internal::startsimulationparams(const KRAmevaEvent* msg) {
  return *msg->startsimulationparams_;
}
const ::sl_pb::StopSimulationParams&
KRAmevaEvent::_Internal::stopsimulationparams(const KRAmevaEvent* msg) {
  return *msg->stopsimulationparams_;
}
const ::sl_pb::SetIndividualPoseParams&
KRAmevaEvent::_Internal::setindividualposeparams(const KRAmevaEvent* msg) {
  return *msg->setindividualposeparams_;
}
const ::sl_pb::ApplyForceToParams&
KRAmevaEvent::_Internal::applyforcetoparams(const KRAmevaEvent* msg) {
  return *msg->applyforcetoparams_;
}
const ::sl_pb::HighlightParams&
KRAmevaEvent::_Internal::highlightparams(const KRAmevaEvent* msg) {
  return *msg->highlightparams_;
}
const ::sl_pb::RemoveHighlightParams&
KRAmevaEvent::_Internal::removehighlightparams(const KRAmevaEvent* msg) {
  return *msg->removehighlightparams_;
}
void KRAmevaEvent::clear_settaskparam() {
  if (settaskparam_ != nullptr) settaskparam_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void KRAmevaEvent::clear_setepisodeparams() {
  if (setepisodeparams_ != nullptr) setepisodeparams_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
void KRAmevaEvent::clear_drawmarkeratparams() {
  if (drawmarkeratparams_ != nullptr) drawmarkeratparams_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
void KRAmevaEvent::clear_drawmarkertrajparams() {
  if (drawmarkertrajparams_ != nullptr) drawmarkertrajparams_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
void KRAmevaEvent::clear_loadlevelparams() {
  if (loadlevelparams_ != nullptr) loadlevelparams_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
void KRAmevaEvent::clear_startloggingparams() {
  if (startloggingparams_ != nullptr) startloggingparams_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
void KRAmevaEvent::clear_getepisodedataparams() {
  if (getepisodedataparams_ != nullptr) getepisodedataparams_->Clear();
  _has_bits_[0] &= ~0x00000040u;
}
void KRAmevaEvent::clear_startsimulationparams() {
  if (startsimulationparams_ != nullptr) startsimulationparams_->Clear();
  _has_bits_[0] &= ~0x00000080u;
}
void KRAmevaEvent::clear_stopsimulationparams() {
  if (stopsimulationparams_ != nullptr) stopsimulationparams_->Clear();
  _has_bits_[0] &= ~0x00000100u;
}
void KRAmevaEvent::clear_setindividualposeparams() {
  if (setindividualposeparams_ != nullptr) setindividualposeparams_->Clear();
  _has_bits_[0] &= ~0x00000200u;
}
void KRAmevaEvent::clear_applyforcetoparams() {
  if (applyforcetoparams_ != nullptr) applyforcetoparams_->Clear();
  _has_bits_[0] &= ~0x00000400u;
}
void KRAmevaEvent::clear_highlightparams() {
  if (highlightparams_ != nullptr) highlightparams_->Clear();
  _has_bits_[0] &= ~0x00000800u;
}
void KRAmevaEvent::clear_removehighlightparams() {
  if (removehighlightparams_ != nullptr) removehighlightparams_->Clear();
  _has_bits_[0] &= ~0x00001000u;
}
KRAmevaEvent::KRAmevaEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:sl_pb.KRAmevaEvent)
}
KRAmevaEvent::KRAmevaEvent(const KRAmevaEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_settaskparam()) {
    settaskparam_ = new ::sl_pb::SetTaskParams(*from.settaskparam_);
  } else {
    settaskparam_ = nullptr;
  }
  if (from._internal_has_setepisodeparams()) {
    setepisodeparams_ = new ::sl_pb::SetEpisodeParams(*from.setepisodeparams_);
  } else {
    setepisodeparams_ = nullptr;
  }
  if (from._internal_has_drawmarkeratparams()) {
    drawmarkeratparams_ = new ::sl_pb::DrawMarkerAtParams(*from.drawmarkeratparams_);
  } else {
    drawmarkeratparams_ = nullptr;
  }
  if (from._internal_has_drawmarkertrajparams()) {
    drawmarkertrajparams_ = new ::sl_pb::DrawMarkerTrajParams(*from.drawmarkertrajparams_);
  } else {
    drawmarkertrajparams_ = nullptr;
  }
  if (from._internal_has_loadlevelparams()) {
    loadlevelparams_ = new ::sl_pb::LoadLevelParams(*from.loadlevelparams_);
  } else {
    loadlevelparams_ = nullptr;
  }
  if (from._internal_has_startloggingparams()) {
    startloggingparams_ = new ::sl_pb::StartLoggingParams(*from.startloggingparams_);
  } else {
    startloggingparams_ = nullptr;
  }
  if (from._internal_has_getepisodedataparams()) {
    getepisodedataparams_ = new ::sl_pb::GetEpisodeDataParams(*from.getepisodedataparams_);
  } else {
    getepisodedataparams_ = nullptr;
  }
  if (from._internal_has_startsimulationparams()) {
    startsimulationparams_ = new ::sl_pb::StartSimulationParams(*from.startsimulationparams_);
  } else {
    startsimulationparams_ = nullptr;
  }
  if (from._internal_has_stopsimulationparams()) {
    stopsimulationparams_ = new ::sl_pb::StopSimulationParams(*from.stopsimulationparams_);
  } else {
    stopsimulationparams_ = nullptr;
  }
  if (from._internal_has_setindividualposeparams()) {
    setindividualposeparams_ = new ::sl_pb::SetIndividualPoseParams(*from.setindividualposeparams_);
  } else {
    setindividualposeparams_ = nullptr;
  }
  if (from._internal_has_applyforcetoparams()) {
    applyforcetoparams_ = new ::sl_pb::ApplyForceToParams(*from.applyforcetoparams_);
  } else {
    applyforcetoparams_ = nullptr;
  }
  if (from._internal_has_highlightparams()) {
    highlightparams_ = new ::sl_pb::HighlightParams(*from.highlightparams_);
  } else {
    highlightparams_ = nullptr;
  }
  if (from._internal_has_removehighlightparams()) {
    removehighlightparams_ = new ::sl_pb::RemoveHighlightParams(*from.removehighlightparams_);
  } else {
    removehighlightparams_ = nullptr;
  }
  functocall_ = from.functocall_;
  // @@protoc_insertion_point(copy_constructor:sl_pb.KRAmevaEvent)
}

void KRAmevaEvent::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_KRAmevaEvent_ameva_2eproto.base);
  ::memset(&settaskparam_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&removehighlightparams_) -
      reinterpret_cast<char*>(&settaskparam_)) + sizeof(removehighlightparams_));
  functocall_ = 1;
}

KRAmevaEvent::~KRAmevaEvent() {
  // @@protoc_insertion_point(destructor:sl_pb.KRAmevaEvent)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void KRAmevaEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete settaskparam_;
  if (this != internal_default_instance()) delete setepisodeparams_;
  if (this != internal_default_instance()) delete drawmarkeratparams_;
  if (this != internal_default_instance()) delete drawmarkertrajparams_;
  if (this != internal_default_instance()) delete loadlevelparams_;
  if (this != internal_default_instance()) delete startloggingparams_;
  if (this != internal_default_instance()) delete getepisodedataparams_;
  if (this != internal_default_instance()) delete startsimulationparams_;
  if (this != internal_default_instance()) delete stopsimulationparams_;
  if (this != internal_default_instance()) delete setindividualposeparams_;
  if (this != internal_default_instance()) delete applyforcetoparams_;
  if (this != internal_default_instance()) delete highlightparams_;
  if (this != internal_default_instance()) delete removehighlightparams_;
}

void KRAmevaEvent::ArenaDtor(void* object) {
  KRAmevaEvent* _this = reinterpret_cast< KRAmevaEvent* >(object);
  (void)_this;
}
void KRAmevaEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void KRAmevaEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const KRAmevaEvent& KRAmevaEvent::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_KRAmevaEvent_ameva_2eproto.base);
  return *internal_default_instance();
}

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(settaskparam_ != nullptr);
      settaskparam_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(setepisodeparams_ != nullptr);
      setepisodeparams_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(drawmarkeratparams_ != nullptr);
      drawmarkeratparams_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(drawmarkertrajparams_ != nullptr);
      drawmarkertrajparams_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(loadlevelparams_ != nullptr);
      loadlevelparams_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(startloggingparams_ != nullptr);
      startloggingparams_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(getepisodedataparams_ != nullptr);
      getepisodedataparams_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(startsimulationparams_ != nullptr);
      startsimulationparams_->Clear();
    }
  }
  if (cached_has_bits & 0x00003f00u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(stopsimulationparams_ != nullptr);
      stopsimulationparams_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(setindividualposeparams_ != nullptr);
      setindividualposeparams_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(applyforcetoparams_ != nullptr);
      applyforcetoparams_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(highlightparams_ != nullptr);
      highlightparams_->Clear();
    }
    if (cached_has_bits & 0x00001000u) {
      GOOGLE_DCHECK(removehighlightparams_ != nullptr);
      removehighlightparams_->Clear();
    }
    functocall_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* KRAmevaEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required .sl_pb.KRAmevaEvent.FuncToCall funcToCall = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::sl_pb::KRAmevaEvent_FuncToCall_IsValid(val))) {
            _internal_set_functocall(static_cast<::sl_pb::KRAmevaEvent_FuncToCall>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.SetTaskParams setTaskParam = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_settaskparam(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.SetEpisodeParams setEpisodeParams = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_setepisodeparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.DrawMarkerAtParams drawMarkerAtParams = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_drawmarkeratparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.DrawMarkerTrajParams drawMarkerTrajParams = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_drawmarkertrajparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.LoadLevelParams loadLevelParams = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_loadlevelparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.StartLoggingParams startLoggingParams = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_startloggingparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.GetEpisodeDataParams getEpisodeDataParams = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_getepisodedataparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.StartSimulationParams startSimulationParams = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_startsimulationparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.StopSimulationParams stopSimulationParams = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_stopsimulationparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.SetIndividualPoseParams setIndividualPoseParams = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_setindividualposeparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.ApplyForceToParams applyForceToParams = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_applyforcetoparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.HighlightParams highlightParams = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_highlightparams(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .sl_pb.RemoveHighlightParams removeHighlightParams = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_removehighlightparams(), 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_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // required .sl_pb.KRAmevaEvent.FuncToCall funcToCall = 1;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_functocall(), target);
  }

  // optional .sl_pb.SetTaskParams setTaskParam = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::settaskparam(this), target, stream);
  }

  // optional .sl_pb.SetEpisodeParams setEpisodeParams = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::setepisodeparams(this), target, stream);
  }

  // optional .sl_pb.DrawMarkerAtParams drawMarkerAtParams = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::drawmarkeratparams(this), target, stream);
  }

  // optional .sl_pb.DrawMarkerTrajParams drawMarkerTrajParams = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::drawmarkertrajparams(this), target, stream);
  }

  // optional .sl_pb.LoadLevelParams loadLevelParams = 6;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::loadlevelparams(this), target, stream);
  }

  // optional .sl_pb.StartLoggingParams startLoggingParams = 7;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::startloggingparams(this), target, stream);
  }

  // optional .sl_pb.GetEpisodeDataParams getEpisodeDataParams = 8;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::getepisodedataparams(this), target, stream);
  }

  // optional .sl_pb.StartSimulationParams startSimulationParams = 9;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::startsimulationparams(this), target, stream);
  }

  // optional .sl_pb.StopSimulationParams stopSimulationParams = 10;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::stopsimulationparams(this), target, stream);
  }

  // optional .sl_pb.SetIndividualPoseParams setIndividualPoseParams = 11;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::setindividualposeparams(this), target, stream);
  }

  // optional .sl_pb.ApplyForceToParams applyForceToParams = 12;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        12, _Internal::applyforcetoparams(this), target, stream);
  }

  // optional .sl_pb.HighlightParams highlightParams = 13;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        13, _Internal::highlightparams(this), target, stream);
  }

  // optional .sl_pb.RemoveHighlightParams removeHighlightParams = 14;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        14, _Internal::removehighlightparams(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:sl_pb.KRAmevaEvent)
  return target;
}

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

  // required .sl_pb.KRAmevaEvent.FuncToCall funcToCall = 1;
  if (_internal_has_functocall()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_functocall());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .sl_pb.SetTaskParams setTaskParam = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *settaskparam_);
    }

    // optional .sl_pb.SetEpisodeParams setEpisodeParams = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *setepisodeparams_);
    }

    // optional .sl_pb.DrawMarkerAtParams drawMarkerAtParams = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *drawmarkeratparams_);
    }

    // optional .sl_pb.DrawMarkerTrajParams drawMarkerTrajParams = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *drawmarkertrajparams_);
    }

    // optional .sl_pb.LoadLevelParams loadLevelParams = 6;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *loadlevelparams_);
    }

    // optional .sl_pb.StartLoggingParams startLoggingParams = 7;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *startloggingparams_);
    }

    // optional .sl_pb.GetEpisodeDataParams getEpisodeDataParams = 8;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *getepisodedataparams_);
    }

    // optional .sl_pb.StartSimulationParams startSimulationParams = 9;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *startsimulationparams_);
    }

  }
  if (cached_has_bits & 0x00001f00u) {
    // optional .sl_pb.StopSimulationParams stopSimulationParams = 10;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *stopsimulationparams_);
    }

    // optional .sl_pb.SetIndividualPoseParams setIndividualPoseParams = 11;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *setindividualposeparams_);
    }

    // optional .sl_pb.ApplyForceToParams applyForceToParams = 12;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *applyforcetoparams_);
    }

    // optional .sl_pb.HighlightParams highlightParams = 13;
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *highlightparams_);
    }

    // optional .sl_pb.RemoveHighlightParams removeHighlightParams = 14;
    if (cached_has_bits & 0x00001000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *removehighlightparams_);
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void KRAmevaEvent::MergeFrom(const KRAmevaEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sl_pb.KRAmevaEvent)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_settaskparam()->::sl_pb::SetTaskParams::MergeFrom(from._internal_settaskparam());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_setepisodeparams()->::sl_pb::SetEpisodeParams::MergeFrom(from._internal_setepisodeparams());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_drawmarkeratparams()->::sl_pb::DrawMarkerAtParams::MergeFrom(from._internal_drawmarkeratparams());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_drawmarkertrajparams()->::sl_pb::DrawMarkerTrajParams::MergeFrom(from._internal_drawmarkertrajparams());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_loadlevelparams()->::sl_pb::LoadLevelParams::MergeFrom(from._internal_loadlevelparams());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_mutable_startloggingparams()->::sl_pb::StartLoggingParams::MergeFrom(from._internal_startloggingparams());
    }
    if (cached_has_bits & 0x00000040u) {
      _internal_mutable_getepisodedataparams()->::sl_pb::GetEpisodeDataParams::MergeFrom(from._internal_getepisodedataparams());
    }
    if (cached_has_bits & 0x00000080u) {
      _internal_mutable_startsimulationparams()->::sl_pb::StartSimulationParams::MergeFrom(from._internal_startsimulationparams());
    }
  }
  if (cached_has_bits & 0x00003f00u) {
    if (cached_has_bits & 0x00000100u) {
      _internal_mutable_stopsimulationparams()->::sl_pb::StopSimulationParams::MergeFrom(from._internal_stopsimulationparams());
    }
    if (cached_has_bits & 0x00000200u) {
      _internal_mutable_setindividualposeparams()->::sl_pb::SetIndividualPoseParams::MergeFrom(from._internal_setindividualposeparams());
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_mutable_applyforcetoparams()->::sl_pb::ApplyForceToParams::MergeFrom(from._internal_applyforcetoparams());
    }
    if (cached_has_bits & 0x00000800u) {
      _internal_mutable_highlightparams()->::sl_pb::HighlightParams::MergeFrom(from._internal_highlightparams());
    }
    if (cached_has_bits & 0x00001000u) {
      _internal_mutable_removehighlightparams()->::sl_pb::RemoveHighlightParams::MergeFrom(from._internal_removehighlightparams());
    }
    if (cached_has_bits & 0x00002000u) {
      functocall_ = from.functocall_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

bool KRAmevaEvent::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_settaskparam()) {
    if (!settaskparam_->IsInitialized()) return false;
  }
  if (_internal_has_setepisodeparams()) {
    if (!setepisodeparams_->IsInitialized()) return false;
  }
  if (_internal_has_drawmarkeratparams()) {
    if (!drawmarkeratparams_->IsInitialized()) return false;
  }
  if (_internal_has_drawmarkertrajparams()) {
    if (!drawmarkertrajparams_->IsInitialized()) return false;
  }
  if (_internal_has_loadlevelparams()) {
    if (!loadlevelparams_->IsInitialized()) return false;
  }
  if (_internal_has_startloggingparams()) {
    if (!startloggingparams_->IsInitialized()) return false;
  }
  if (_internal_has_getepisodedataparams()) {
    if (!getepisodedataparams_->IsInitialized()) return false;
  }
  if (_internal_has_startsimulationparams()) {
    if (!startsimulationparams_->IsInitialized()) return false;
  }
  if (_internal_has_setindividualposeparams()) {
    if (!setindividualposeparams_->IsInitialized()) return false;
  }
  if (_internal_has_applyforcetoparams()) {
    if (!applyforcetoparams_->IsInitialized()) return false;
  }
  if (_internal_has_highlightparams()) {
    if (!highlightparams_->IsInitialized()) return false;
  }
  if (_internal_has_removehighlightparams()) {
    if (!removehighlightparams_->IsInitialized()) return false;
  }
  return true;
}

void KRAmevaEvent::InternalSwap(KRAmevaEvent* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(KRAmevaEvent, removehighlightparams_)
      + sizeof(KRAmevaEvent::removehighlightparams_)
      - PROTOBUF_FIELD_OFFSET(KRAmevaEvent, settaskparam_)>(
          reinterpret_cast<char*>(&settaskparam_),
          reinterpret_cast<char*>(&other->settaskparam_));
  swap(functocall_, other->functocall_);
}

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

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

void KRAmevaResponse::InitAsDefaultInstance() {
}
class KRAmevaResponse::_Internal {
 public:
  using HasBits = decltype(std::declval<KRAmevaResponse>()._has_bits_);
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_text(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_filename(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_filedata(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_datalength(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000010) ^ 0x00000010) != 0;
  }
};

KRAmevaResponse::KRAmevaResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:sl_pb.KRAmevaResponse)
}
KRAmevaResponse::KRAmevaResponse(const KRAmevaResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_text()) {
    text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_text(),
      GetArena());
  }
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_filename()) {
    filename_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_filename(),
      GetArena());
  }
  filedata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_filedata()) {
    filedata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_filedata(),
      GetArena());
  }
  ::memcpy(&datalength_, &from.datalength_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&datalength_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:sl_pb.KRAmevaResponse)
}

void KRAmevaResponse::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_KRAmevaResponse_ameva_2eproto.base);
  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  filedata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  datalength_ = 0;
  type_ = 1;
}

KRAmevaResponse::~KRAmevaResponse() {
  // @@protoc_insertion_point(destructor:sl_pb.KRAmevaResponse)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void KRAmevaResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  filedata_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void KRAmevaResponse::ArenaDtor(void* object) {
  KRAmevaResponse* _this = reinterpret_cast< KRAmevaResponse* >(object);
  (void)_this;
}
void KRAmevaResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void KRAmevaResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const KRAmevaResponse& KRAmevaResponse::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_KRAmevaResponse_ameva_2eproto.base);
  return *internal_default_instance();
}

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      text_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      filename_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      filedata_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x00000018u) {
    datalength_ = 0;
    type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* KRAmevaResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required .sl_pb.KRAmevaResponse.ResponseType type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::sl_pb::KRAmevaResponse_ResponseType_IsValid(val))) {
            _internal_set_type(static_cast<::sl_pb::KRAmevaResponse_ResponseType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string text = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_text();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "sl_pb.KRAmevaResponse.text");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string fileName = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_filename();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "sl_pb.KRAmevaResponse.fileName");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes fileData = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_filedata();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 dataLength = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_datalength(&has_bits);
          datalength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // required .sl_pb.KRAmevaResponse.ResponseType type = 1;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  // optional string text = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "sl_pb.KRAmevaResponse.text");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_text(), target);
  }

  // optional string fileName = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_filename().data(), static_cast<int>(this->_internal_filename().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "sl_pb.KRAmevaResponse.fileName");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_filename(), target);
  }

  // optional bytes fileData = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->WriteBytesMaybeAliased(
        4, this->_internal_filedata(), target);
  }

  // optional int32 dataLength = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_datalength(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:sl_pb.KRAmevaResponse)
  return target;
}

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

  // required .sl_pb.KRAmevaResponse.ResponseType type = 1;
  if (_internal_has_type()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string text = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_text());
    }

    // optional string fileName = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_filename());
    }

    // optional bytes fileData = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_filedata());
    }

    // optional int32 dataLength = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_datalength());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

void KRAmevaResponse::MergeFrom(const KRAmevaResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sl_pb.KRAmevaResponse)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_text(from._internal_text());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_filename(from._internal_filename());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_filedata(from._internal_filedata());
    }
    if (cached_has_bits & 0x00000008u) {
      datalength_ = from.datalength_;
    }
    if (cached_has_bits & 0x00000010u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

bool KRAmevaResponse::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void KRAmevaResponse::InternalSwap(KRAmevaResponse* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  text_.Swap(&other->text_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  filename_.Swap(&other->filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  filedata_.Swap(&other->filedata_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(datalength_, other->datalength_);
  swap(type_, other->type_);
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace sl_pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sl_pb::KRAmevaEvent* Arena::CreateMaybeMessage< ::sl_pb::KRAmevaEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::sl_pb::KRAmevaEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::sl_pb::KRAmevaResponse* Arena::CreateMaybeMessage< ::sl_pb::KRAmevaResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::sl_pb::KRAmevaResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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


text:
from __future__ import unicode_literals

from django.db import models, migrations
import django.db.models.deletion

class Migration(migrations.Migration):

    dependencies = [
        ('lists', '0011_auto_20150307_1734'),
    ]

    operations = [
        migrations.AlterField(
            model_name='callmapping',
            name='data1_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data2_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data3_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data4_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data5_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data6_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data7_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='callmapping',
            name='data8_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='address_1_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='address_2_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='address_3_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='age_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='city_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='date_of_birth_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='do_not_mail_reason_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='name_family_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='name_first_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='name_middle_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='name_prefix_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='name_suffix_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='postcode_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='serial_number_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='suburb_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='tel_day_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='tel_evening_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='tel_mobile_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='demographicsmapping',
            name='tel_work_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field10_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field11_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field12_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field13_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field14_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field15_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field16_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field17_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field18_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field19_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field1_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field20_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field2_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field3_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field4_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field5_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field6_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field7_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field8_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='extramapping',
            name='field9_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='notemapping',
            name='note1_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='notemapping',
            name='note2_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
        migrations.AlterField(
            model_name='notemapping',
            name='note3_source',
            field=models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.PROTECT, blank=True, to='lists.CsvColumn', null=True),
            preserve_default=True,
        ),
    ]

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Github\Api;

/**
 * Creating, deleting and listing authorizations.
 *
 * @link   http://developer.github.com/v3/oauth_authorizations/
 * @author Evgeniy Guseletov <d46k16@gmail.com>
 */
class Authorizations extends AbstractApi
{
    /**
     * List all authorizations.
     *
     * @return array
     */
    public function all()
    {
        return $this->get('authorizations');
    }

    /**
     * Show a single authorization.
     *
     * @param $clientId
     *
     * @return array
     */
    public function show($clientId)
    {
        return $this->get('authorizations/'.rawurlencode($clientId));
    }

    /**
     * Create an authorization.
     *
     * @param array $params
     * @param null $OTPCode
     *
     * @return array
     */
    public function create(array $params, $OTPCode = null)
    {
        $headers = null === $OTPCode ? array() : array('X-GitHub-OTP' => $OTPCode);

        return $this->post('authorizations', $params, $headers);
    }

    /**
     * Update an authorization.
     *
     * @param $clientId
     * @param array $params
     *
     * @return array
     */
    public function update($clientId, array $params)
    {
        return $this->patch('authorizations/'.rawurlencode($clientId), $params);
    }

    /**
     * Remove an authorization.
     *
     * @param $clientId
     *
     * @return array
     */
    public function remove($clientId)
    {
        return $this->delete('authorizations/'.rawurlencode($clientId));
    }

    /**
     * Check an authorization.
     *
     * @param $clientId
     * @param $token
     *
     * @return array
     */
    public function check($clientId, $token)
    {
        return $this->get('applications/'.rawurlencode($clientId).'/tokens/'.rawurlencode($token));
    }

    /**
     * Reset an authorization.
     *
     * @param $clientId
     * @param $token
     *
     * @return array
     */
    public function reset($clientId, $token)
    {
        return $this->post('applications/'.rawurlencode($clientId).'/tokens/'.rawurlencode($token));
    }

    /**
     * Remove an authorization.
     *
     * @param $clientId
     * @param $token
     */
    public function revoke($clientId, $token)
    {
        $this->delete('applications/'.rawurlencode($clientId).'/tokens/'.rawurlencode($token));
    }

    /**
     * Revoke all authorizations.
     *
     * @param $clientId
     */
    public function revokeAll($clientId)
    {
        $this->delete('applications/'.rawurlencode($clientId).'/tokens');
    }
}


text:
package io.fabric8.kubernetes.client.impl;

import io.fabric8.kubernetes.api.model.HasMetadata;
import io.fabric8.kubernetes.api.model.Pod;
import io.fabric8.kubernetes.api.model.Service;
import io.fabric8.kubernetes.api.model.apps.Deployment;
import io.fabric8.kubernetes.client.Config;
import io.fabric8.kubernetes.client.ConfigBuilder;
import io.fabric8.kubernetes.client.KubernetesClient;
import io.fabric8.kubernetes.client.KubernetesClientException;
import io.fabric8.kubernetes.client.dsl.ParameterNamespaceListVisitFromServerGetDeleteRecreateWaitApplicable;
import io.fabric8.kubernetes.client.http.BasicBuilder;
import io.fabric8.kubernetes.client.http.HttpHeaders;
import io.fabric8.kubernetes.client.utils.HttpClientUtils;
import io.fabric8.kubernetes.client.utils.Serialization;
import io.fabric8.kubernetes.client.utils.Utils;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;

/**
 * @author wangyushuai2@jd.com
 */
class KubernetesClientImplTest {

  private static final String TEST_CONFIG_YML_FILE = Utils
      .filePath(KubernetesClientImplTest.class.getResource("/test-config.yml"));

  private KubernetesClientImpl defaultKubernetesClient;

  @BeforeEach
  public void setUp() {
    defaultKubernetesClient = new KubernetesClientImpl();
  }

  @AfterEach
  public void tearDown() {
    defaultKubernetesClient.close();
    defaultKubernetesClient = null;
  }

  @Test
  void testInitClientWithCustomHeaderConfiguration() {
    final Map<String, String> customHeaders = new HashMap<>();
    customHeaders.put("user-id", "test-user");
    customHeaders.put("cluster-id", "test-cluster");
    final Config configWithCustomerHeaders = new ConfigBuilder().withCustomHeaders(customHeaders).build();

    BasicBuilder basicBuilder = Mockito.mock(BasicBuilder.class);
    HttpClientUtils.createApplicableInterceptors(configWithCustomerHeaders, null).get("HEADER")
        .before(basicBuilder, Mockito.mock(HttpHeaders.class));
    Mockito.verify(basicBuilder, Mockito.times(1)).header("user-id", "test-user");
  }

  @Test
  void testInitClientWithDefaultConfiguration() {
    final Config defaultEmptyConfig = new ConfigBuilder().build();

    BasicBuilder basicBuilder = Mockito.mock(BasicBuilder.class);
    HttpClientUtils.createApplicableInterceptors(defaultEmptyConfig, null).get("HEADER")
        .before(basicBuilder, Mockito.mock(HttpHeaders.class));

    Mockito.verify(basicBuilder, Mockito.never()).header("user-id", "test-user");
  }

  @Test
  @DisplayName("load, InputStream containing List with windows like line-ends (CRLF), all list items should be available")
  void loadWithWindowsLineSeparatorsString() throws Exception {
    // Given
    final List<String> fileLines = Files.readAllLines(
        new File(KubernetesClientImplTest.class.getResource("/test-list.yml").getFile()).toPath(), StandardCharsets.UTF_8);
    final String crlfFile = String.join(" \r\n", fileLines);
    // When
    final List<HasMetadata> result = new KubernetesClientImpl()
        .load(new ByteArrayInputStream(crlfFile.getBytes(StandardCharsets.UTF_8))).get();
    // Then
    assertThat(result)
        .hasSize(2)
        .hasAtLeastOneElementOfType(Service.class)
        .hasAtLeastOneElementOfType(Deployment.class);
  }

  @Test
  void shouldInstantiateClientUsingYaml() {
    File configYml = new File(TEST_CONFIG_YML_FILE);
    try (InputStream is = new FileInputStream(configYml)) {
      KubernetesClient client = KubernetesClientImpl.fromConfig(is);
      assertEquals("http://some.url/", client.getMasterUrl().toString());
    } catch (Exception e) {
      fail();
    }
  }

  @Test
  void shouldInstantiateClientUsingSerializeDeserialize() {
    KubernetesClientImpl original = new KubernetesClientImpl();
    String json = Serialization.asJson(original.getConfiguration());
    KubernetesClientImpl copy = KubernetesClientImpl.fromConfig(json);

    assertEquals(original.getConfiguration().getMasterUrl(), copy.getConfiguration().getMasterUrl());
    assertEquals(original.getConfiguration().getOauthToken(), copy.getConfiguration().getOauthToken());
    assertEquals(original.getConfiguration().getNamespace(), copy.getConfiguration().getNamespace());
    assertEquals(original.getConfiguration().getUsername(), copy.getConfiguration().getUsername());
    assertEquals(original.getConfiguration().getPassword(), copy.getConfiguration().getPassword());
  }

  @Test
  void shouldPropagateImpersonateSettings() {

    final Map<String, List<String>> extras = new HashMap<>();
    extras.put("c", Collections.singletonList("d"));

    final Config config = new ConfigBuilder()
        .withImpersonateUsername("a")
        .withImpersonateGroups("b")
        .withImpersonateExtras(extras)
        .build();

    final KubernetesClientImpl client = new KubernetesClientImpl(config);
    final Config currentConfig = client.getConfiguration();

    assertEquals("a", currentConfig.getImpersonateUsername());
    assertArrayEquals(new String[] { "b" }, currentConfig.getImpersonateGroups());
    assertEquals(Collections.singletonList("d"), currentConfig.getImpersonateExtras().get("c"));
  }

  @Test
  @DisplayName("resource(String).get with HasMetadata should deserialize")
  void resourceFromStringWithHasMetadata() {
    assertThat(new KubernetesClientImpl().resource("apiVersion: v1\nkind: Pod").get())
        .isInstanceOf(Pod.class);
  }

  @Test
  @DisplayName("resource(String) with no HasMetadata should throwException")
  void resourceFromStringWithInvalid() {
    final KubernetesClient kc = new KubernetesClientImpl();
    assertThatExceptionOfType(KubernetesClientException.class)
        .isThrownBy(() -> kc.resource("NotAPod"))
        .withMessageStartingWith("Unable to create a valid resource from the provided object");
  }

  @Test
  @DisplayName("resource(InputStream).get with HasMetadata should deserialize")
  void resourceFromInputStreamWithHasMetadata() throws IOException {
    final String podYaml = "apiVersion: v1\nkind: Pod";
    try (InputStream is = new ByteArrayInputStream(podYaml.getBytes(StandardCharsets.UTF_8))) {
      assertThat(new KubernetesClientImpl().resource(is).get())
          .isInstanceOf(Pod.class);
    }
  }

  @Test
  @DisplayName("resource(InputStream) with no HasMetadata should throwException")
  void resourceFromInputStreamWithInvalid() throws IOException {
    final KubernetesClient kc = new KubernetesClientImpl();
    final String podYaml = "NotAPod";
    try (InputStream is = new ByteArrayInputStream(podYaml.getBytes(StandardCharsets.UTF_8))) {
      assertThatExceptionOfType(KubernetesClientException.class)
          .isThrownBy(() -> kc.resource(is))
          .withMessageStartingWith("Unable to create a valid resource from the provided object");
    }
  }

  @Test
  @DisplayName("load(InputStream).get with HasMetadata should deserialize")
  void loadFromInputStreamWithHasMetadata() throws IOException {
    final String podYaml = "apiVersion: v1\nkind: Pod";
    try (InputStream is = new ByteArrayInputStream(podYaml.getBytes(StandardCharsets.UTF_8))) {
      assertThat(new KubernetesClientImpl().load(is).get())
          .containsExactly(new Pod());
    }
  }

  @Test
  @DisplayName("load(InputStream).get with no HasMetadata should throwException")
  void loadFromInputStreamWithInvalid() throws IOException {
    final String podYaml = "NotAPod";
    try (InputStream is = new ByteArrayInputStream(podYaml.getBytes(StandardCharsets.UTF_8))) {
      final ParameterNamespaceListVisitFromServerGetDeleteRecreateWaitApplicable<HasMetadata> load = new KubernetesClientImpl()
          .load(is);
      assertThatIllegalArgumentException()
          .isThrownBy(load::get)
          .withMessageStartingWith("Could not convert item to a list of HasMetadata");
    }
  }
}


text:
package org.ausdigital.apecconnect.invoice.model

import enumeratum.{EnumEntry, PlayEnum}
import org.ausdigital.apecconnect.common.model.ApecConnectEnumEntry
import org.ausdigital.apecconnect.db.model.{Record, RecordId}
import org.ausdigital.apecconnect.participants.model.Participant.ParticipantId
import org.joda.money.Money
import org.joda.time.DateTime
import play.api.libs.json.{Json, OFormat}

import scalaz.Equal
import scala.collection.immutable.IndexedSeq

sealed abstract class PaymentOption(val value: Int, val name: String) extends EnumEntry with ApecConnectEnumEntry

object PaymentOption extends PlayEnum[PaymentOption] {

  case object Cash extends PaymentOption(1, "Cash")

  case object VISA extends PaymentOption(2, "VISA")

  case object MasterCard extends PaymentOption(3, "MasterCard")

  case object PayPal extends PaymentOption(4, "PayPal")

  override val values: IndexedSeq[PaymentOption] = findValues

  implicit val equal: Equal[PaymentOption] = Equal.equalA
}

/**
  * Invoice generated by Participant to indicate a payment is requested.
  */
object Invoice {

  import com.github.nscala_money.money.json.PlayImports._
  import org.ausdigital.apecconnect.common.model.JsonFormatters._

  final case class InvoiceData(issuerId: ParticipantId,
                               dateIssued: DateTime,
                               dateDue: DateTime,
                               isPaid: Boolean,
                               isAccepted: Boolean,
                               amount: Money,
                               paymentReference: Option[String],
                               paymentOptions: Seq[PaymentOption],
                               paymentMethod: Option[PaymentOption])

  final case class PendingInvoice(dateIssued: DateTime,
                                  dateDue: DateTime,
                                  isPaid: Boolean,
                                  isAccepted: Boolean,
                                  amount: Money,
                                  paymentReference: Option[String],
                                  paymentOptions: Seq[PaymentOption],
                                  paymentMethod: Option[PaymentOption])

  type Invoice = Record[InvoiceData]

  type InvoiceId = RecordId[Invoice]

  def pendingInvoiceToInvoiceData(issuerId: ParticipantId, pending: PendingInvoice) = InvoiceData(
    issuerId = issuerId,
    dateIssued = pending.dateIssued,
    dateDue = pending.dateDue,
    isPaid = pending.isPaid,
    isAccepted = pending.isAccepted,
    amount = pending.amount,
    paymentReference = pending.paymentReference,
    paymentOptions = pending.paymentOptions,
    paymentMethod = pending.paymentMethod
  )

  implicit val invoiceFormatter: OFormat[InvoiceData] = Json.format[InvoiceData]

  implicit val pendingInvoiceFormatter: OFormat[PendingInvoice] = Json.format[PendingInvoice]
}