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

#include "s2clientprotocol/sc2api.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AbilityData_s2clientprotocol_2fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_Action_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ActionChat_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ActionError_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ActionObserverCameraFollowPlayer_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ActionObserverCameraFollowUnits_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ActionObserverPlayerPerspective_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fraw_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ActionRaw_s2clientprotocol_2fraw_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fui_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<9> scc_info_ActionUI_s2clientprotocol_2fui_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AvailableAbility_s2clientprotocol_2fcommon_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BuffData_s2clientprotocol_2fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChatReceived_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EffectData_s2clientprotocol_2fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LocalMap_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_Observation_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fraw_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<6> scc_info_ObservationRaw_s2clientprotocol_2fraw_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ObservationRender_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fui_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_ObservationUI_s2clientprotocol_2fui_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlayerCommon_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlayerInfo_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlayerResult_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlayerSetup_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Point2D_s2clientprotocol_2fcommon_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PortSet_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestAvailableMaps_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestData_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestGameInfo_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestLeaveGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestMapCommand_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestObservation_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestPing_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fquery_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_RequestQuery_s2clientprotocol_2fquery_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestQuickLoad_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestQuickSave_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestQuit_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestReplayInfo_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestRestartGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestSaveMap_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestSaveReplay_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RequestStep_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseAction_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseAvailableMaps_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseCreateGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseDebug_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseJoinGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseLeaveGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseMapCommand_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseObserverAction_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponsePing_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fquery_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ResponseQuery_s2clientprotocol_2fquery_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseQuickLoad_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseQuickSave_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseQuit_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseRestartGame_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseSaveMap_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseSaveReplay_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseStartReplay_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ResponseStep_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fscore_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Score_s2clientprotocol_2fscore_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Size2DI_s2clientprotocol_2fcommon_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fsc2api_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fraw_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_StartRaw_s2clientprotocol_2fraw_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_UnitTypeData_s2clientprotocol_2fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_UpgradeData_s2clientprotocol_2fdata_2eproto;
namespace SC2APIProtocol {
class RequestDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Request> _instance;
  const ::SC2APIProtocol::RequestCreateGame* create_game_;
  const ::SC2APIProtocol::RequestJoinGame* join_game_;
  const ::SC2APIProtocol::RequestRestartGame* restart_game_;
  const ::SC2APIProtocol::RequestStartReplay* start_replay_;
  const ::SC2APIProtocol::RequestLeaveGame* leave_game_;
  const ::SC2APIProtocol::RequestQuickSave* quick_save_;
  const ::SC2APIProtocol::RequestQuickLoad* quick_load_;
  const ::SC2APIProtocol::RequestQuit* quit_;
  const ::SC2APIProtocol::RequestGameInfo* game_info_;
  const ::SC2APIProtocol::RequestObservation* observation_;
  const ::SC2APIProtocol::RequestAction* action_;
  const ::SC2APIProtocol::RequestObserverAction* obs_action_;
  const ::SC2APIProtocol::RequestStep* step_;
  const ::SC2APIProtocol::RequestData* data_;
  const ::SC2APIProtocol::RequestQuery* query_;
  const ::SC2APIProtocol::RequestSaveReplay* save_replay_;
  const ::SC2APIProtocol::RequestMapCommand* map_command_;
  const ::SC2APIProtocol::RequestReplayInfo* replay_info_;
  const ::SC2APIProtocol::RequestAvailableMaps* available_maps_;
  const ::SC2APIProtocol::RequestSaveMap* save_map_;
  const ::SC2APIProtocol::RequestPing* ping_;
  const ::SC2APIProtocol::RequestDebug* debug_;
} _Request_default_instance_;
class ResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Response> _instance;
  const ::SC2APIProtocol::ResponseCreateGame* create_game_;
  const ::SC2APIProtocol::ResponseJoinGame* join_game_;
  const ::SC2APIProtocol::ResponseRestartGame* restart_game_;
  const ::SC2APIProtocol::ResponseStartReplay* start_replay_;
  const ::SC2APIProtocol::ResponseLeaveGame* leave_game_;
  const ::SC2APIProtocol::ResponseQuickSave* quick_save_;
  const ::SC2APIProtocol::ResponseQuickLoad* quick_load_;
  const ::SC2APIProtocol::ResponseQuit* quit_;
  const ::SC2APIProtocol::ResponseGameInfo* game_info_;
  const ::SC2APIProtocol::ResponseObservation* observation_;
  const ::SC2APIProtocol::ResponseAction* action_;
  const ::SC2APIProtocol::ResponseObserverAction* obs_action_;
  const ::SC2APIProtocol::ResponseStep* step_;
  const ::SC2APIProtocol::ResponseData* data_;
  const ::SC2APIProtocol::ResponseQuery* query_;
  const ::SC2APIProtocol::ResponseSaveReplay* save_replay_;
  const ::SC2APIProtocol::ResponseReplayInfo* replay_info_;
  const ::SC2APIProtocol::ResponseAvailableMaps* available_maps_;
  const ::SC2APIProtocol::ResponseSaveMap* save_map_;
  const ::SC2APIProtocol::ResponseMapCommand* map_command_;
  const ::SC2APIProtocol::ResponsePing* ping_;
  const ::SC2APIProtocol::ResponseDebug* debug_;
} _Response_default_instance_;
class RequestCreateGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestCreateGame> _instance;
  const ::SC2APIProtocol::LocalMap* local_map_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr battlenet_map_name_;
} _RequestCreateGame_default_instance_;
class LocalMapDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LocalMap> _instance;
} _LocalMap_default_instance_;
class ResponseCreateGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseCreateGame> _instance;
} _ResponseCreateGame_default_instance_;
class RequestJoinGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestJoinGame> _instance;
  int race_;
  ::PROTOBUF_NAMESPACE_ID::uint32 observed_player_id_;
} _RequestJoinGame_default_instance_;
class PortSetDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PortSet> _instance;
} _PortSet_default_instance_;
class ResponseJoinGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseJoinGame> _instance;
} _ResponseJoinGame_default_instance_;
class RequestRestartGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestRestartGame> _instance;
} _RequestRestartGame_default_instance_;
class ResponseRestartGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseRestartGame> _instance;
} _ResponseRestartGame_default_instance_;
class RequestStartReplayDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestStartReplay> _instance;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr replay_path_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr replay_data_;
} _RequestStartReplay_default_instance_;
class ResponseStartReplayDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseStartReplay> _instance;
} _ResponseStartReplay_default_instance_;
class RequestMapCommandDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestMapCommand> _instance;
} _RequestMapCommand_default_instance_;
class ResponseMapCommandDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseMapCommand> _instance;
} _ResponseMapCommand_default_instance_;
class RequestLeaveGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestLeaveGame> _instance;
} _RequestLeaveGame_default_instance_;
class ResponseLeaveGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseLeaveGame> _instance;
} _ResponseLeaveGame_default_instance_;
class RequestQuickSaveDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestQuickSave> _instance;
} _RequestQuickSave_default_instance_;
class ResponseQuickSaveDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseQuickSave> _instance;
} _ResponseQuickSave_default_instance_;
class RequestQuickLoadDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestQuickLoad> _instance;
} _RequestQuickLoad_default_instance_;
class ResponseQuickLoadDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseQuickLoad> _instance;
} _ResponseQuickLoad_default_instance_;
class RequestQuitDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestQuit> _instance;
} _RequestQuit_default_instance_;
class ResponseQuitDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseQuit> _instance;
} _ResponseQuit_default_instance_;
class RequestGameInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestGameInfo> _instance;
} _RequestGameInfo_default_instance_;
class ResponseGameInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseGameInfo> _instance;
} _ResponseGameInfo_default_instance_;
class RequestObservationDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestObservation> _instance;
} _RequestObservation_default_instance_;
class ResponseObservationDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseObservation> _instance;
} _ResponseObservation_default_instance_;
class ChatReceivedDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ChatReceived> _instance;
} _ChatReceived_default_instance_;
class RequestActionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestAction> _instance;
} _RequestAction_default_instance_;
class ResponseActionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseAction> _instance;
} _ResponseAction_default_instance_;
class RequestObserverActionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestObserverAction> _instance;
} _RequestObserverAction_default_instance_;
class ResponseObserverActionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseObserverAction> _instance;
} _ResponseObserverAction_default_instance_;
class RequestStepDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestStep> _instance;
} _RequestStep_default_instance_;
class ResponseStepDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseStep> _instance;
} _ResponseStep_default_instance_;
class RequestDataDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestData> _instance;
} _RequestData_default_instance_;
class ResponseDataDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseData> _instance;
} _ResponseData_default_instance_;
class RequestSaveReplayDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestSaveReplay> _instance;
} _RequestSaveReplay_default_instance_;
class ResponseSaveReplayDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseSaveReplay> _instance;
} _ResponseSaveReplay_default_instance_;
class RequestReplayInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestReplayInfo> _instance;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr replay_path_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr replay_data_;
} _RequestReplayInfo_default_instance_;
class PlayerInfoExtraDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlayerInfoExtra> _instance;
} _PlayerInfoExtra_default_instance_;
class ResponseReplayInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseReplayInfo> _instance;
} _ResponseReplayInfo_default_instance_;
class RequestAvailableMapsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestAvailableMaps> _instance;
} _RequestAvailableMaps_default_instance_;
class ResponseAvailableMapsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseAvailableMaps> _instance;
} _ResponseAvailableMaps_default_instance_;
class RequestSaveMapDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestSaveMap> _instance;
} _RequestSaveMap_default_instance_;
class ResponseSaveMapDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseSaveMap> _instance;
} _ResponseSaveMap_default_instance_;
class RequestPingDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestPing> _instance;
} _RequestPing_default_instance_;
class ResponsePingDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponsePing> _instance;
} _ResponsePing_default_instance_;
class RequestDebugDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RequestDebug> _instance;
} _RequestDebug_default_instance_;
class ResponseDebugDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ResponseDebug> _instance;
} _ResponseDebug_default_instance_;
class PlayerSetupDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlayerSetup> _instance;
} _PlayerSetup_default_instance_;
class SpatialCameraSetupDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SpatialCameraSetup> _instance;
} _SpatialCameraSetup_default_instance_;
class InterfaceOptionsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<InterfaceOptions> _instance;
} _InterfaceOptions_default_instance_;
class PlayerInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlayerInfo> _instance;
} _PlayerInfo_default_instance_;
class PlayerCommonDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlayerCommon> _instance;
} _PlayerCommon_default_instance_;
class ObservationDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Observation> _instance;
} _Observation_default_instance_;
class ActionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Action> _instance;
} _Action_default_instance_;
class ActionChatDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionChat> _instance;
} _ActionChat_default_instance_;
class ActionErrorDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionError> _instance;
} _ActionError_default_instance_;
class ObserverActionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ObserverAction> _instance;
  const ::SC2APIProtocol::ActionObserverPlayerPerspective* player_perspective_;
  const ::SC2APIProtocol::ActionObserverCameraMove* camera_move_;
  const ::SC2APIProtocol::ActionObserverCameraFollowPlayer* camera_follow_player_;
  const ::SC2APIProtocol::ActionObserverCameraFollowUnits* camera_follow_units_;
} _ObserverAction_default_instance_;
class ActionObserverPlayerPerspectiveDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionObserverPlayerPerspective> _instance;
} _ActionObserverPlayerPerspective_default_instance_;
class ActionObserverCameraMoveDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionObserverCameraMove> _instance;
} _ActionObserverCameraMove_default_instance_;
class ActionObserverCameraFollowPlayerDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionObserverCameraFollowPlayer> _instance;
} _ActionObserverCameraFollowPlayer_default_instance_;
class ActionObserverCameraFollowUnitsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionObserverCameraFollowUnits> _instance;
} _ActionObserverCameraFollowUnits_default_instance_;
class PlayerResultDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlayerResult> _instance;
} _PlayerResult_default_instance_;
}  // namespace SC2APIProtocol
static void InitDefaultsscc_info_Action_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_Action_default_instance_;
    new (ptr) ::SC2APIProtocol::Action();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::Action::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_Action_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_Action_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_ActionRaw_s2clientprotocol_2fraw_2eproto.base,
      &scc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_ActionUI_s2clientprotocol_2fui_2eproto.base,
      &scc_info_ActionChat_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_ActionChat_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ActionChat_default_instance_;
    new (ptr) ::SC2APIProtocol::ActionChat();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ActionChat::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ActionError_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ActionError_default_instance_;
    new (ptr) ::SC2APIProtocol::ActionError();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ActionError::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ActionObserverCameraFollowPlayer_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ActionObserverCameraFollowPlayer_default_instance_;
    new (ptr) ::SC2APIProtocol::ActionObserverCameraFollowPlayer();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ActionObserverCameraFollowPlayer::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ActionObserverCameraFollowUnits_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ActionObserverCameraFollowUnits_default_instance_;
    new (ptr) ::SC2APIProtocol::ActionObserverCameraFollowUnits();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ActionObserverCameraFollowUnits::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ActionObserverCameraMove_default_instance_;
    new (ptr) ::SC2APIProtocol::ActionObserverCameraMove();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ActionObserverCameraMove::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_Point2D_s2clientprotocol_2fcommon_2eproto.base,}};

static void InitDefaultsscc_info_ActionObserverPlayerPerspective_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ActionObserverPlayerPerspective_default_instance_;
    new (ptr) ::SC2APIProtocol::ActionObserverPlayerPerspective();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ActionObserverPlayerPerspective::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ChatReceived_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ChatReceived_default_instance_;
    new (ptr) ::SC2APIProtocol::ChatReceived();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ChatReceived::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_InterfaceOptions_default_instance_;
    new (ptr) ::SC2APIProtocol::InterfaceOptions();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::InterfaceOptions::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_LocalMap_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_LocalMap_default_instance_;
    new (ptr) ::SC2APIProtocol::LocalMap();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::LocalMap::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_Observation_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_Observation_default_instance_;
    new (ptr) ::SC2APIProtocol::Observation();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::Observation::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_Observation_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 7, 0, InitDefaultsscc_info_Observation_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_PlayerCommon_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_AvailableAbility_s2clientprotocol_2fcommon_2eproto.base,
      &scc_info_Score_s2clientprotocol_2fscore_2eproto.base,
      &scc_info_ObservationRaw_s2clientprotocol_2fraw_2eproto.base,
      &scc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_ObservationRender_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_ObservationUI_s2clientprotocol_2fui_2eproto.base,}};

static void InitDefaultsscc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ObserverAction_default_instance_;
    new (ptr) ::SC2APIProtocol::ObserverAction();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ObserverAction::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_ActionObserverPlayerPerspective_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ActionObserverCameraFollowPlayer_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ActionObserverCameraFollowUnits_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_PlayerCommon_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_PlayerCommon_default_instance_;
    new (ptr) ::SC2APIProtocol::PlayerCommon();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::PlayerCommon::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_PlayerInfo_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_PlayerInfo_default_instance_;
    new (ptr) ::SC2APIProtocol::PlayerInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::PlayerInfo::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_PlayerInfoExtra_default_instance_;
    new (ptr) ::SC2APIProtocol::PlayerInfoExtra();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::PlayerInfoExtra::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_PlayerInfo_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_PlayerResult_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_PlayerResult_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_PlayerResult_default_instance_;
    new (ptr) ::SC2APIProtocol::PlayerResult();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::PlayerResult::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_PlayerSetup_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_PlayerSetup_default_instance_;
    new (ptr) ::SC2APIProtocol::PlayerSetup();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::PlayerSetup::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_PortSet_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_PortSet_default_instance_;
    new (ptr) ::SC2APIProtocol::PortSet();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::PortSet::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_Request_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_Request_default_instance_;
    new (ptr) ::SC2APIProtocol::Request();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::Request::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<22> scc_info_Request_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 22, 0, InitDefaultsscc_info_Request_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestRestartGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestLeaveGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestQuickSave_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestQuickLoad_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestQuit_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestGameInfo_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestObservation_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestStep_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestData_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestQuery_s2clientprotocol_2fquery_2eproto.base,
      &scc_info_RequestSaveReplay_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestMapCommand_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestReplayInfo_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestAvailableMaps_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestSaveMap_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestPing_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestAction_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestAction();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestAction::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_Action_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_RequestAvailableMaps_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestAvailableMaps_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestAvailableMaps();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestAvailableMaps::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestCreateGame_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestCreateGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestCreateGame::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_LocalMap_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_PlayerSetup_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_RequestData_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestData_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestData();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestData::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestDebug_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestDebug();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestDebug::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto.base,}};

static void InitDefaultsscc_info_RequestGameInfo_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestGameInfo_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestGameInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestGameInfo::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestJoinGame_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestJoinGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestJoinGame::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_PortSet_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_RequestLeaveGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestLeaveGame_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestLeaveGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestLeaveGame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestMapCommand_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestMapCommand_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestMapCommand();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestMapCommand::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestObservation_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestObservation_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestObservation();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestObservation::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestObserverAction_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestObserverAction();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestObserverAction::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_RequestPing_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestPing_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestPing();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestPing::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestQuickLoad_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestQuickLoad_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestQuickLoad();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestQuickLoad::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestQuickSave_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestQuickSave_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestQuickSave();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestQuickSave::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestQuit_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestQuit_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestQuit();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestQuit::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestReplayInfo_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestReplayInfo_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestReplayInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestReplayInfo::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestRestartGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestRestartGame_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestRestartGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestRestartGame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestSaveMap_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestSaveMap_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestSaveMap();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestSaveMap::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestSaveReplay_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestSaveReplay_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestSaveReplay();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestSaveReplay::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestStartReplay_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestStartReplay();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestStartReplay::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_RequestStep_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_RequestStep_default_instance_;
    new (ptr) ::SC2APIProtocol::RequestStep();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::RequestStep::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_Response_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_Response_default_instance_;
    new (ptr) ::SC2APIProtocol::Response();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::Response::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<22> scc_info_Response_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 22, 0, InitDefaultsscc_info_Response_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_ResponseCreateGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseJoinGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseRestartGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseStartReplay_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseLeaveGame_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseQuickSave_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseQuickLoad_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseQuit_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseAction_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseObserverAction_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseStep_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseQuery_s2clientprotocol_2fquery_2eproto.base,
      &scc_info_ResponseSaveReplay_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseAvailableMaps_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseSaveMap_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseMapCommand_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponsePing_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ResponseDebug_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_ResponseAction_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseAction_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseAction();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseAction::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseAvailableMaps_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseAvailableMaps_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseAvailableMaps();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseAvailableMaps::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseCreateGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseCreateGame_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseCreateGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseCreateGame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseData_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseData();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseData::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, 0, InitDefaultsscc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_AbilityData_s2clientprotocol_2fdata_2eproto.base,
      &scc_info_UnitTypeData_s2clientprotocol_2fdata_2eproto.base,
      &scc_info_UpgradeData_s2clientprotocol_2fdata_2eproto.base,
      &scc_info_BuffData_s2clientprotocol_2fdata_2eproto.base,
      &scc_info_EffectData_s2clientprotocol_2fdata_2eproto.base,}};

static void InitDefaultsscc_info_ResponseDebug_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseDebug_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseDebug();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseDebug::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseGameInfo_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseGameInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseGameInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_PlayerInfo_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_StartRaw_s2clientprotocol_2fraw_2eproto.base,
      &scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_ResponseJoinGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseJoinGame_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseJoinGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseJoinGame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseLeaveGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseLeaveGame_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseLeaveGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseLeaveGame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseMapCommand_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseMapCommand_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseMapCommand();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseMapCommand::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseObservation_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseObservation();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseObservation::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, 0, InitDefaultsscc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_Action_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ActionError_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_Observation_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_PlayerResult_s2clientprotocol_2fsc2api_2eproto.base,
      &scc_info_ChatReceived_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_ResponseObserverAction_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseObserverAction_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseObserverAction();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseObserverAction::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponsePing_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponsePing_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponsePing();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponsePing::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseQuickLoad_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseQuickLoad_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseQuickLoad();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseQuickLoad::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseQuickSave_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseQuickSave_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseQuickSave();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseQuickSave::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseQuit_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseQuit_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseQuit();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseQuit::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseReplayInfo_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseReplayInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseReplayInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto.base,}};

static void InitDefaultsscc_info_ResponseRestartGame_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseRestartGame_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseRestartGame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseRestartGame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseSaveMap_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseSaveMap_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseSaveMap();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseSaveMap::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseSaveReplay_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseSaveReplay_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseSaveReplay();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseSaveReplay::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseStartReplay_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseStartReplay_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseStartReplay();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseStartReplay::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ResponseStep_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_ResponseStep_default_instance_;
    new (ptr) ::SC2APIProtocol::ResponseStep();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::ResponseStep::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::SC2APIProtocol::_SpatialCameraSetup_default_instance_;
    new (ptr) ::SC2APIProtocol::SpatialCameraSetup();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::SC2APIProtocol::SpatialCameraSetup::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto}, {
      &scc_info_Size2DI_s2clientprotocol_2fcommon_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_s2clientprotocol_2fsc2api_2eproto[63];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[14];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_s2clientprotocol_2fsc2api_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_s2clientprotocol_2fsc2api_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Request, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Request, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Request, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, create_game_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, join_game_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, restart_game_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, start_replay_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, leave_game_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, quick_save_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, quick_load_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, quit_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, game_info_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, observation_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, action_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, obs_action_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, step_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, data_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, query_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, save_replay_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, map_command_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, replay_info_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, available_maps_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, save_map_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, ping_),
  offsetof(::SC2APIProtocol::RequestDefaultTypeInternal, debug_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Request, id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Request, request_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, create_game_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, join_game_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, restart_game_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, start_replay_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, leave_game_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, quick_save_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, quick_load_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, quit_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, game_info_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, observation_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, action_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, obs_action_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, step_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, data_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, query_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, save_replay_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, replay_info_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, available_maps_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, save_map_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, map_command_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, ping_),
  offsetof(::SC2APIProtocol::ResponseDefaultTypeInternal, debug_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, status_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Response, response_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  0,
  ~0u,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::RequestCreateGameDefaultTypeInternal, local_map_),
  offsetof(::SC2APIProtocol::RequestCreateGameDefaultTypeInternal, battlenet_map_name_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, player_setup_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, disable_fog_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, random_seed_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, realtime_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestCreateGame, Map_),
  ~0u,
  ~0u,
  ~0u,
  1,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::LocalMap, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::LocalMap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::LocalMap, map_path_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::LocalMap, map_data_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseCreateGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseCreateGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseCreateGame, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseCreateGame, error_details_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::RequestJoinGameDefaultTypeInternal, race_),
  offsetof(::SC2APIProtocol::RequestJoinGameDefaultTypeInternal, observed_player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, options_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, server_ports_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, client_ports_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, shared_port_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, player_name_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, host_ip_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestJoinGame, participation_),
  ~0u,
  ~0u,
  2,
  3,
  ~0u,
  4,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PortSet, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PortSet, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PortSet, game_port_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PortSet, base_port_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseJoinGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseJoinGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseJoinGame, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseJoinGame, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseJoinGame, error_details_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestRestartGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestRestartGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseRestartGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseRestartGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseRestartGame, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseRestartGame, error_details_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseRestartGame, need_hard_reset_),
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::RequestStartReplayDefaultTypeInternal, replay_path_),
  offsetof(::SC2APIProtocol::RequestStartReplayDefaultTypeInternal, replay_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, map_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, observed_player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, options_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, disable_fog_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, realtime_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, record_replay_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStartReplay, replay_),
  ~0u,
  ~0u,
  0,
  2,
  1,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStartReplay, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStartReplay, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStartReplay, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStartReplay, error_details_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestMapCommand, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestMapCommand, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestMapCommand, trigger_cmd_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseMapCommand, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseMapCommand, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseMapCommand, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseMapCommand, error_details_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestLeaveGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestLeaveGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseLeaveGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseLeaveGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestQuickSave, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestQuickSave, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseQuickSave, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseQuickSave, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestQuickLoad, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestQuickLoad, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseQuickLoad, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseQuickLoad, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestQuit, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestQuit, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseQuit, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseQuit, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestGameInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestGameInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, map_name_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, mod_names_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, local_map_path_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, player_info_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, start_raw_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseGameInfo, options_),
  0,
  ~0u,
  1,
  ~0u,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObservation, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObservation, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObservation, disable_fog_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObservation, game_loop_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, actions_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, action_errors_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, observation_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, player_result_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObservation, chat_),
  ~0u,
  ~0u,
  0,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ChatReceived, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ChatReceived, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ChatReceived, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ChatReceived, message_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestAction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestAction, actions_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAction, result_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObserverAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObserverAction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestObserverAction, actions_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObserverAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseObserverAction, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStep, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStep, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestStep, count_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStep, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStep, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseStep, simulation_loop_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, ability_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, unit_type_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, upgrade_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, buff_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestData, effect_id_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, abilities_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, units_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, upgrades_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, buffs_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseData, effects_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestSaveReplay, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestSaveReplay, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseSaveReplay, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseSaveReplay, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseSaveReplay, data_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestReplayInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestReplayInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestReplayInfo, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::RequestReplayInfoDefaultTypeInternal, replay_path_),
  offsetof(::SC2APIProtocol::RequestReplayInfoDefaultTypeInternal, replay_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestReplayInfo, download_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestReplayInfo, replay_),
  ~0u,
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfoExtra, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfoExtra, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfoExtra, player_info_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfoExtra, player_result_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfoExtra, player_mmr_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfoExtra, player_apm_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, map_name_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, local_map_path_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, player_info_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, game_duration_loops_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, game_duration_seconds_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, game_version_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, data_version_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, data_build_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, base_build_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, error_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseReplayInfo, error_details_),
  0,
  1,
  ~0u,
  5,
  6,
  2,
  4,
  7,
  8,
  9,
  3,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestAvailableMaps, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestAvailableMaps, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAvailableMaps, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAvailableMaps, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAvailableMaps, local_map_paths_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseAvailableMaps, battlenet_map_names_),
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestSaveMap, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestSaveMap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestSaveMap, map_path_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestSaveMap, map_data_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseSaveMap, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseSaveMap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseSaveMap, error_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestPing, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestPing, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponsePing, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponsePing, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponsePing, game_version_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponsePing, data_version_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponsePing, data_build_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponsePing, base_build_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestDebug, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestDebug, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RequestDebug, debug_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseDebug, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ResponseDebug, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, type_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, race_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, difficulty_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, player_name_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerSetup, ai_build_),
  3,
  1,
  4,
  0,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, resolution_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, minimap_resolution_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, width_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, crop_to_playable_area_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::SpatialCameraSetup, allow_cheating_layers_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, raw_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, score_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, feature_layer_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, render_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, show_cloaked_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, show_burrowed_shadows_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, show_placeholders_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, raw_affects_selection_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::InterfaceOptions, raw_crop_to_playable_area_),
  2,
  3,
  0,
  1,
  4,
  5,
  6,
  7,
  8,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, type_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, race_requested_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, race_actual_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, difficulty_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, ai_build_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerInfo, player_name_),
  1,
  5,
  2,
  3,
  6,
  4,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, minerals_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, vespene_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, food_cap_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, food_used_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, food_army_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, food_workers_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, idle_worker_count_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, army_count_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, warp_gate_count_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerCommon, larva_count_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, game_loop_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, player_common_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, alerts_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, abilities_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, score_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, raw_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, feature_layer_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, render_data_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Observation, ui_data_),
  6,
  0,
  ~0u,
  ~0u,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, action_raw_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, action_feature_layer_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, action_render_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, action_ui_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, action_chat_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Action, game_loop_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionChat, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionChat, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionChat, channel_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionChat, message_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionError, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionError, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionError, unit_tag_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionError, ability_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionError, result_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObserverAction, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObserverAction, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObserverAction, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::ObserverActionDefaultTypeInternal, player_perspective_),
  offsetof(::SC2APIProtocol::ObserverActionDefaultTypeInternal, camera_move_),
  offsetof(::SC2APIProtocol::ObserverActionDefaultTypeInternal, camera_follow_player_),
  offsetof(::SC2APIProtocol::ObserverActionDefaultTypeInternal, camera_follow_units_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObserverAction, action_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverPlayerPerspective, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverPlayerPerspective, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverPlayerPerspective, player_id_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraMove, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraMove, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraMove, world_pos_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraMove, distance_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraFollowPlayer, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraFollowPlayer, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraFollowPlayer, player_id_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraFollowUnits, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraFollowUnits, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionObserverCameraFollowUnits, unit_tags_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerResult, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerResult, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerResult, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PlayerResult, result_),
  0,
  1,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 29, sizeof(::SC2APIProtocol::Request)},
  { 52, 83, sizeof(::SC2APIProtocol::Response)},
  { 108, 120, sizeof(::SC2APIProtocol::RequestCreateGame)},
  { 126, 133, sizeof(::SC2APIProtocol::LocalMap)},
  { 135, 142, sizeof(::SC2APIProtocol::ResponseCreateGame)},
  { 144, 158, sizeof(::SC2APIProtocol::RequestJoinGame)},
  { 166, 173, sizeof(::SC2APIProtocol::PortSet)},
  { 175, 183, sizeof(::SC2APIProtocol::ResponseJoinGame)},
  { 186, 191, sizeof(::SC2APIProtocol::RequestRestartGame)},
  { 191, 199, sizeof(::SC2APIProtocol::ResponseRestartGame)},
  { 202, 216, sizeof(::SC2APIProtocol::RequestStartReplay)},
  { 224, 231, sizeof(::SC2APIProtocol::ResponseStartReplay)},
  { 233, 239, sizeof(::SC2APIProtocol::RequestMapCommand)},
  { 240, 247, sizeof(::SC2APIProtocol::ResponseMapCommand)},
  { 249, 254, sizeof(::SC2APIProtocol::RequestLeaveGame)},
  { 254, 259, sizeof(::SC2APIProtocol::ResponseLeaveGame)},
  { 259, 264, sizeof(::SC2APIProtocol::RequestQuickSave)},
  { 264, 269, sizeof(::SC2APIProtocol::ResponseQuickSave)},
  { 269, 274, sizeof(::SC2APIProtocol::RequestQuickLoad)},
  { 274, 279, sizeof(::SC2APIProtocol::ResponseQuickLoad)},
  { 279, 284, sizeof(::SC2APIProtocol::RequestQuit)},
  { 284, 289, sizeof(::SC2APIProtocol::ResponseQuit)},
  { 289, 294, sizeof(::SC2APIProtocol::RequestGameInfo)},
  { 294, 305, sizeof(::SC2APIProtocol::ResponseGameInfo)},
  { 311, 318, sizeof(::SC2APIProtocol::RequestObservation)},
  { 320, 330, sizeof(::SC2APIProtocol::ResponseObservation)},
  { 335, 342, sizeof(::SC2APIProtocol::ChatReceived)},
  { 344, 350, sizeof(::SC2APIProtocol::RequestAction)},
  { 351, 357, sizeof(::SC2APIProtocol::ResponseAction)},
  { 358, 364, sizeof(::SC2APIProtocol::RequestObserverAction)},
  { 365, 370, sizeof(::SC2APIProtocol::ResponseObserverAction)},
  { 370, 376, sizeof(::SC2APIProtocol::RequestStep)},
  { 377, 383, sizeof(::SC2APIProtocol::ResponseStep)},
  { 384, 394, sizeof(::SC2APIProtocol::RequestData)},
  { 399, 409, sizeof(::SC2APIProtocol::ResponseData)},
  { 414, 419, sizeof(::SC2APIProtocol::RequestSaveReplay)},
  { 419, 425, sizeof(::SC2APIProtocol::ResponseSaveReplay)},
  { 426, 435, sizeof(::SC2APIProtocol::RequestReplayInfo)},
  { 438, 447, sizeof(::SC2APIProtocol::PlayerInfoExtra)},
  { 451, 467, sizeof(::SC2APIProtocol::ResponseReplayInfo)},
  { 478, 483, sizeof(::SC2APIProtocol::RequestAvailableMaps)},
  { 483, 490, sizeof(::SC2APIProtocol::ResponseAvailableMaps)},
  { 492, 499, sizeof(::SC2APIProtocol::RequestSaveMap)},
  { 501, 507, sizeof(::SC2APIProtocol::ResponseSaveMap)},
  { 508, 513, sizeof(::SC2APIProtocol::RequestPing)},
  { 513, 522, sizeof(::SC2APIProtocol::ResponsePing)},
  { 526, 532, sizeof(::SC2APIProtocol::RequestDebug)},
  { 533, 538, sizeof(::SC2APIProtocol::ResponseDebug)},
  { 538, 548, sizeof(::SC2APIProtocol::PlayerSetup)},
  { 553, 563, sizeof(::SC2APIProtocol::SpatialCameraSetup)},
  { 568, 582, sizeof(::SC2APIProtocol::InterfaceOptions)},
  { 591, 603, sizeof(::SC2APIProtocol::PlayerInfo)},
  { 610, 626, sizeof(::SC2APIProtocol::PlayerCommon)},
  { 637, 651, sizeof(::SC2APIProtocol::Observation)},
  { 660, 671, sizeof(::SC2APIProtocol::Action)},
  { 677, 684, sizeof(::SC2APIProtocol::ActionChat)},
  { 686, 694, sizeof(::SC2APIProtocol::ActionError)},
  { 697, 707, sizeof(::SC2APIProtocol::ObserverAction)},
  { 711, 717, sizeof(::SC2APIProtocol::ActionObserverPlayerPerspective)},
  { 718, 725, sizeof(::SC2APIProtocol::ActionObserverCameraMove)},
  { 727, 733, sizeof(::SC2APIProtocol::ActionObserverCameraFollowPlayer)},
  { 734, 740, sizeof(::SC2APIProtocol::ActionObserverCameraFollowUnits)},
  { 741, 748, sizeof(::SC2APIProtocol::PlayerResult)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Request_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Response_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestCreateGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_LocalMap_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseCreateGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestJoinGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PortSet_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseJoinGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestRestartGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseRestartGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestStartReplay_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseStartReplay_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestMapCommand_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseMapCommand_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestLeaveGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseLeaveGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestQuickSave_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseQuickSave_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestQuickLoad_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseQuickLoad_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestQuit_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseQuit_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestGameInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseGameInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestObservation_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseObservation_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ChatReceived_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestObserverAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseObserverAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestStep_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseStep_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestSaveReplay_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseSaveReplay_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestReplayInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PlayerInfoExtra_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseReplayInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestAvailableMaps_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseAvailableMaps_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestSaveMap_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseSaveMap_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestPing_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponsePing_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RequestDebug_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ResponseDebug_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PlayerSetup_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_SpatialCameraSetup_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_InterfaceOptions_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PlayerInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PlayerCommon_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Observation_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Action_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionChat_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionError_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ObserverAction_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionObserverPlayerPerspective_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionObserverCameraMove_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionObserverCameraFollowPlayer_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionObserverCameraFollowUnits_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PlayerResult_default_instance_),
};

const char descriptor_table_protodef_s2clientprotocol_2fsc2api_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\035s2clientprotocol/sc2api.proto\022\016SC2APIP"
  "rotocol\032\035s2clientprotocol/common.proto\032\033"
  "s2clientprotocol/data.proto\032\034s2clientpro"
  "tocol/debug.proto\032\034s2clientprotocol/erro"
  "r.proto\032\034s2clientprotocol/query.proto\032\032s"
  "2clientprotocol/raw.proto\032\034s2clientproto"
  "col/score.proto\032\036s2clientprotocol/spatia"
  "l.proto\032\031s2clientprotocol/ui.proto\"\303\t\n\007R"
  "equest\0228\n\013create_game\030\001 \001(\0132!.SC2APIProt"
  "ocol.RequestCreateGameH\000\0224\n\tjoin_game\030\002 "
  "\001(\0132\037.SC2APIProtocol.RequestJoinGameH\000\022:"
  "\n\014restart_game\030\003 \001(\0132\".SC2APIProtocol.Re"
  "questRestartGameH\000\022:\n\014start_replay\030\004 \001(\013"
  "2\".SC2APIProtocol.RequestStartReplayH\000\0226"
  "\n\nleave_game\030\005 \001(\0132 .SC2APIProtocol.Requ"
  "estLeaveGameH\000\0226\n\nquick_save\030\006 \001(\0132 .SC2"
  "APIProtocol.RequestQuickSaveH\000\0226\n\nquick_"
  "load\030\007 \001(\0132 .SC2APIProtocol.RequestQuick"
  "LoadH\000\022+\n\004quit\030\010 \001(\0132\033.SC2APIProtocol.Re"
  "questQuitH\000\0224\n\tgame_info\030\t \001(\0132\037.SC2APIP"
  "rotocol.RequestGameInfoH\000\0229\n\013observation"
  "\030\n \001(\0132\".SC2APIProtocol.RequestObservati"
  "onH\000\022/\n\006action\030\013 \001(\0132\035.SC2APIProtocol.Re"
  "questActionH\000\022;\n\nobs_action\030\025 \001(\0132%.SC2A"
  "PIProtocol.RequestObserverActionH\000\022+\n\004st"
  "ep\030\014 \001(\0132\033.SC2APIProtocol.RequestStepH\000\022"
  "+\n\004data\030\r \001(\0132\033.SC2APIProtocol.RequestDa"
  "taH\000\022-\n\005query\030\016 \001(\0132\034.SC2APIProtocol.Req"
  "uestQueryH\000\0228\n\013save_replay\030\017 \001(\0132!.SC2AP"
  "IProtocol.RequestSaveReplayH\000\0228\n\013map_com"
  "mand\030\026 \001(\0132!.SC2APIProtocol.RequestMapCo"
  "mmandH\000\0228\n\013replay_info\030\020 \001(\0132!.SC2APIPro"
  "tocol.RequestReplayInfoH\000\022>\n\016available_m"
  "aps\030\021 \001(\0132$.SC2APIProtocol.RequestAvaila"
  "bleMapsH\000\0222\n\010save_map\030\022 \001(\0132\036.SC2APIProt"
  "ocol.RequestSaveMapH\000\022+\n\004ping\030\023 \001(\0132\033.SC"
  "2APIProtocol.RequestPingH\000\022-\n\005debug\030\024 \001("
  "\0132\034.SC2APIProtocol.RequestDebugH\000\022\n\n\002id\030"
  "a \001(\rB\t\n\007request\"\222\n\n\010Response\0229\n\013create_"
  "game\030\001 \001(\0132\".SC2APIProtocol.ResponseCrea"
  "teGameH\000\0225\n\tjoin_game\030\002 \001(\0132 .SC2APIProt"
  "ocol.ResponseJoinGameH\000\022;\n\014restart_game\030"
  "\003 \001(\0132#.SC2APIProtocol.ResponseRestartGa"
  "meH\000\022;\n\014start_replay\030\004 \001(\0132#.SC2APIProto"
  "col.ResponseStartReplayH\000\0227\n\nleave_game\030"
  "\005 \001(\0132!.SC2APIProtocol.ResponseLeaveGame"
  "H\000\0227\n\nquick_save\030\006 \001(\0132!.SC2APIProtocol."
  "ResponseQuickSaveH\000\0227\n\nquick_load\030\007 \001(\0132"
  "!.SC2APIProtocol.ResponseQuickLoadH\000\022,\n\004"
  "quit\030\010 \001(\0132\034.SC2APIProtocol.ResponseQuit"
  "H\000\0225\n\tgame_info\030\t \001(\0132 .SC2APIProtocol.R"
  "esponseGameInfoH\000\022:\n\013observation\030\n \001(\0132#"
  ".SC2APIProtocol.ResponseObservationH\000\0220\n"
  "\006action\030\013 \001(\0132\036.SC2APIProtocol.ResponseA"
  "ctionH\000\022<\n\nobs_action\030\025 \001(\0132&.SC2APIProt"
  "ocol.ResponseObserverActionH\000\022,\n\004step\030\014 "
  "\001(\0132\034.SC2APIProtocol.ResponseStepH\000\022,\n\004d"
  "ata\030\r \001(\0132\034.SC2APIProtocol.ResponseDataH"
  "\000\022.\n\005query\030\016 \001(\0132\035.SC2APIProtocol.Respon"
  "seQueryH\000\0229\n\013save_replay\030\017 \001(\0132\".SC2APIP"
  "rotocol.ResponseSaveReplayH\000\0229\n\013replay_i"
  "nfo\030\020 \001(\0132\".SC2APIProtocol.ResponseRepla"
  "yInfoH\000\022\?\n\016available_maps\030\021 \001(\0132%.SC2API"
  "Protocol.ResponseAvailableMapsH\000\0223\n\010save"
  "_map\030\022 \001(\0132\037.SC2APIProtocol.ResponseSave"
  "MapH\000\0229\n\013map_command\030\026 \001(\0132\".SC2APIProto"
  "col.ResponseMapCommandH\000\022,\n\004ping\030\023 \001(\0132\034"
  ".SC2APIProtocol.ResponsePingH\000\022.\n\005debug\030"
  "\024 \001(\0132\035.SC2APIProtocol.ResponseDebugH\000\022\n"
  "\n\002id\030a \001(\r\022\r\n\005error\030b \003(\t\022&\n\006status\030c \001("
  "\0162\026.SC2APIProtocol.StatusB\n\n\010response\"\326\001"
  "\n\021RequestCreateGame\022-\n\tlocal_map\030\001 \001(\0132\030"
  ".SC2APIProtocol.LocalMapH\000\022\034\n\022battlenet_"
  "map_name\030\002 \001(\tH\000\0221\n\014player_setup\030\003 \003(\0132\033"
  ".SC2APIProtocol.PlayerSetup\022\023\n\013disable_f"
  "og\030\004 \001(\010\022\023\n\013random_seed\030\005 \001(\r\022\020\n\010realtim"
  "e\030\006 \001(\010B\005\n\003Map\".\n\010LocalMap\022\020\n\010map_path\030\001"
  " \001(\t\022\020\n\010map_data\030\007 \001(\014\"\234\002\n\022ResponseCreat"
  "eGame\0227\n\005error\030\001 \001(\0162(.SC2APIProtocol.Re"
  "sponseCreateGame.Error\022\025\n\rerror_details\030"
  "\002 \001(\t\"\265\001\n\005Error\022\016\n\nMissingMap\020\001\022\022\n\016Inval"
  "idMapPath\020\002\022\022\n\016InvalidMapData\020\003\022\022\n\016Inval"
  "idMapName\020\004\022\024\n\020InvalidMapHandle\020\005\022\026\n\022Mis"
  "singPlayerSetup\020\006\022\026\n\022InvalidPlayerSetup\020"
  "\007\022\032\n\026MultiplayerUnsupported\020\010\"\262\002\n\017Reques"
  "tJoinGame\022$\n\004race\030\001 \001(\0162\024.SC2APIProtocol"
  ".RaceH\000\022\034\n\022observed_player_id\030\002 \001(\rH\000\0221\n"
  "\007options\030\003 \001(\0132 .SC2APIProtocol.Interfac"
  "eOptions\022-\n\014server_ports\030\004 \001(\0132\027.SC2APIP"
  "rotocol.PortSet\022-\n\014client_ports\030\005 \003(\0132\027."
  "SC2APIProtocol.PortSet\022\023\n\013shared_port\030\006 "
  "\001(\005\022\023\n\013player_name\030\007 \001(\t\022\017\n\007host_ip\030\010 \001("
  "\tB\017\n\rparticipation\"/\n\007PortSet\022\021\n\tgame_po"
  "rt\030\001 \001(\005\022\021\n\tbase_port\030\002 \001(\005\"\202\003\n\020Response"
  "JoinGame\022\021\n\tplayer_id\030\001 \001(\r\0225\n\005error\030\002 \001"
  "(\0162&.SC2APIProtocol.ResponseJoinGame.Err"
  "or\022\025\n\rerror_details\030\003 \001(\t\"\214\002\n\005Error\022\030\n\024M"
  "issingParticipation\020\001\022\033\n\027InvalidObserved"
  "PlayerId\020\002\022\022\n\016MissingOptions\020\003\022\020\n\014Missin"
  "gPorts\020\004\022\014\n\010GameFull\020\005\022\017\n\013LaunchError\020\006\022"
  "\026\n\022FeatureUnsupported\020\007\022\022\n\016NoSpaceForUse"
  "r\020\010\022\023\n\017MapDoesNotExist\020\t\022\021\n\rCannotOpenMa"
  "p\020\n\022\021\n\rChecksumError\020\013\022\020\n\014NetworkError\020\014"
  "\022\016\n\nOtherError\020\r\"\024\n\022RequestRestartGame\"\231"
  "\001\n\023ResponseRestartGame\0228\n\005error\030\001 \001(\0162)."
  "SC2APIProtocol.ResponseRestartGame.Error"
  "\022\025\n\rerror_details\030\002 \001(\t\022\027\n\017need_hard_res"
  "et\030\003 \001(\010\"\030\n\005Error\022\017\n\013LaunchError\020\001\"\353\001\n\022R"
  "equestStartReplay\022\025\n\013replay_path\030\001 \001(\tH\000"
  "\022\025\n\013replay_data\030\005 \001(\014H\000\022\020\n\010map_data\030\006 \001("
  "\014\022\032\n\022observed_player_id\030\002 \001(\005\0221\n\007options"
  "\030\003 \001(\0132 .SC2APIProtocol.InterfaceOptions"
  "\022\023\n\013disable_fog\030\004 \001(\010\022\020\n\010realtime\030\007 \001(\010\022"
  "\025\n\rrecord_replay\030\010 \001(\010B\010\n\006replay\"\207\002\n\023Res"
  "ponseStartReplay\0228\n\005error\030\001 \001(\0162).SC2API"
  "Protocol.ResponseStartReplay.Error\022\025\n\rer"
  "ror_details\030\002 \001(\t\"\236\001\n\005Error\022\021\n\rMissingRe"
  "play\020\001\022\025\n\021InvalidReplayPath\020\002\022\025\n\021Invalid"
  "ReplayData\020\003\022\022\n\016InvalidMapData\020\004\022\033\n\027Inva"
  "lidObservedPlayerId\020\005\022\022\n\016MissingOptions\020"
  "\006\022\017\n\013LaunchError\020\007\"(\n\021RequestMapCommand\022"
  "\023\n\013trigger_cmd\030\001 \001(\t\"\201\001\n\022ResponseMapComm"
  "and\0227\n\005error\030\001 \001(\0162(.SC2APIProtocol.Resp"
  "onseMapCommand.Error\022\025\n\rerror_details\030\002 "
  "\001(\t\"\033\n\005Error\022\022\n\016NoTriggerError\020\001\"\022\n\020Requ"
  "estLeaveGame\"\023\n\021ResponseLeaveGame\"\022\n\020Req"
  "uestQuickSave\"\023\n\021ResponseQuickSave\"\022\n\020Re"
  "questQuickLoad\"\023\n\021ResponseQuickLoad\"\r\n\013R"
  "equestQuit\"\016\n\014ResponseQuit\"\021\n\017RequestGam"
  "eInfo\"\340\001\n\020ResponseGameInfo\022\020\n\010map_name\030\001"
  " \001(\t\022\021\n\tmod_names\030\006 \003(\t\022\026\n\016local_map_pat"
  "h\030\002 \001(\t\022/\n\013player_info\030\003 \003(\0132\032.SC2APIPro"
  "tocol.PlayerInfo\022+\n\tstart_raw\030\004 \001(\0132\030.SC"
  "2APIProtocol.StartRaw\0221\n\007options\030\005 \001(\0132 "
  ".SC2APIProtocol.InterfaceOptions\"<\n\022Requ"
  "estObservation\022\023\n\013disable_fog\030\001 \001(\010\022\021\n\tg"
  "ame_loop\030\002 \001(\r\"\205\002\n\023ResponseObservation\022\'"
  "\n\007actions\030\001 \003(\0132\026.SC2APIProtocol.Action\022"
  "2\n\raction_errors\030\002 \003(\0132\033.SC2APIProtocol."
  "ActionError\0220\n\013observation\030\003 \001(\0132\033.SC2AP"
  "IProtocol.Observation\0223\n\rplayer_result\030\004"
  " \003(\0132\034.SC2APIProtocol.PlayerResult\022*\n\004ch"
  "at\030\005 \003(\0132\034.SC2APIProtocol.ChatReceived\"2"
  "\n\014ChatReceived\022\021\n\tplayer_id\030\001 \001(\r\022\017\n\007mes"
  "sage\030\002 \001(\t\"8\n\rRequestAction\022\'\n\007actions\030\001"
  " \003(\0132\026.SC2APIProtocol.Action\">\n\016Response"
  "Action\022,\n\006result\030\001 \003(\0162\034.SC2APIProtocol."
  "ActionResult\"H\n\025RequestObserverAction\022/\n"
  "\007actions\030\001 \003(\0132\036.SC2APIProtocol.Observer"
  "Action\"\030\n\026ResponseObserverAction\"\034\n\013Requ"
  "estStep\022\r\n\005count\030\001 \001(\r\"\'\n\014ResponseStep\022\027"
  "\n\017simulation_loop\030\001 \001(\r\"o\n\013RequestData\022\022"
  "\n\nability_id\030\001 \001(\010\022\024\n\014unit_type_id\030\002 \001(\010"
  "\022\022\n\nupgrade_id\030\003 \001(\010\022\017\n\007buff_id\030\004 \001(\010\022\021\n"
  "\teffect_id\030\005 \001(\010\"\360\001\n\014ResponseData\022.\n\tabi"
  "lities\030\001 \003(\0132\033.SC2APIProtocol.AbilityDat"
  "a\022+\n\005units\030\002 \003(\0132\034.SC2APIProtocol.UnitTy"
  "peData\022-\n\010upgrades\030\003 \003(\0132\033.SC2APIProtoco"
  "l.UpgradeData\022\'\n\005buffs\030\004 \003(\0132\030.SC2APIPro"
  "tocol.BuffData\022+\n\007effects\030\005 \003(\0132\032.SC2API"
  "Protocol.EffectData\"\023\n\021RequestSaveReplay"
  "\"\"\n\022ResponseSaveReplay\022\014\n\004data\030\001 \001(\014\"b\n\021"
  "RequestReplayInfo\022\025\n\013replay_path\030\001 \001(\tH\000"
  "\022\025\n\013replay_data\030\002 \001(\014H\000\022\025\n\rdownload_data"
  "\030\003 \001(\010B\010\n\006replay\"\237\001\n\017PlayerInfoExtra\022/\n\013"
  "player_info\030\001 \001(\0132\032.SC2APIProtocol.Playe"
  "rInfo\0223\n\rplayer_result\030\002 \001(\0132\034.SC2APIPro"
  "tocol.PlayerResult\022\022\n\nplayer_mmr\030\003 \001(\005\022\022"
  "\n\nplayer_apm\030\004 \001(\005\"\303\003\n\022ResponseReplayInf"
  "o\022\020\n\010map_name\030\001 \001(\t\022\026\n\016local_map_path\030\002 "
  "\001(\t\0224\n\013player_info\030\003 \003(\0132\037.SC2APIProtoco"
  "l.PlayerInfoExtra\022\033\n\023game_duration_loops"
  "\030\004 \001(\r\022\035\n\025game_duration_seconds\030\005 \001(\002\022\024\n"
  "\014game_version\030\006 \001(\t\022\024\n\014data_version\030\013 \001("
  "\t\022\022\n\ndata_build\030\007 \001(\r\022\022\n\nbase_build\030\010 \001("
  "\r\0227\n\005error\030\t \001(\0162(.SC2APIProtocol.Respon"
  "seReplayInfo.Error\022\025\n\rerror_details\030\n \001("
  "\t\"m\n\005Error\022\021\n\rMissingReplay\020\001\022\025\n\021Invalid"
  "ReplayPath\020\002\022\025\n\021InvalidReplayData\020\003\022\020\n\014P"
  "arsingError\020\004\022\021\n\rDownloadError\020\005\"\026\n\024Requ"
  "estAvailableMaps\"M\n\025ResponseAvailableMap"
  "s\022\027\n\017local_map_paths\030\001 \003(\t\022\033\n\023battlenet_"
  "map_names\030\002 \003(\t\"4\n\016RequestSaveMap\022\020\n\010map"
  "_path\030\001 \001(\t\022\020\n\010map_data\030\002 \001(\014\"d\n\017Respons"
  "eSaveMap\0224\n\005error\030\001 \001(\0162%.SC2APIProtocol"
  ".ResponseSaveMap.Error\"\033\n\005Error\022\022\n\016Inval"
  "idMapData\020\001\"\r\n\013RequestPing\"b\n\014ResponsePi"
  "ng\022\024\n\014game_version\030\001 \001(\t\022\024\n\014data_version"
  "\030\002 \001(\t\022\022\n\ndata_build\030\003 \001(\r\022\022\n\nbase_build"
  "\030\004 \001(\r\";\n\014RequestDebug\022+\n\005debug\030\001 \003(\0132\034."
  "SC2APIProtocol.DebugCommand\"\017\n\rResponseD"
  "ebug\"\313\001\n\013PlayerSetup\022(\n\004type\030\001 \001(\0162\032.SC2"
  "APIProtocol.PlayerType\022\"\n\004race\030\002 \001(\0162\024.S"
  "C2APIProtocol.Race\022.\n\ndifficulty\030\003 \001(\0162\032"
  ".SC2APIProtocol.Difficulty\022\023\n\013player_nam"
  "e\030\004 \001(\t\022)\n\010ai_build\030\005 \001(\0162\027.SC2APIProtoc"
  "ol.AIBuild\"\303\001\n\022SpatialCameraSetup\022+\n\nres"
  "olution\030\002 \001(\0132\027.SC2APIProtocol.Size2DI\0223"
  "\n\022minimap_resolution\030\003 \001(\0132\027.SC2APIProto"
  "col.Size2DI\022\r\n\005width\030\001 \001(\002\022\035\n\025crop_to_pl"
  "ayable_area\030\004 \001(\010\022\035\n\025allow_cheating_laye"
  "rs\030\005 \001(\010\"\257\002\n\020InterfaceOptions\022\013\n\003raw\030\001 \001"
  "(\010\022\r\n\005score\030\002 \001(\010\0229\n\rfeature_layer\030\003 \001(\013"
  "2\".SC2APIProtocol.SpatialCameraSetup\0222\n\006"
  "render\030\004 \001(\0132\".SC2APIProtocol.SpatialCam"
  "eraSetup\022\024\n\014show_cloaked\030\005 \001(\010\022\035\n\025show_b"
  "urrowed_shadows\030\t \001(\010\022\031\n\021show_placeholde"
  "rs\030\010 \001(\010\022\035\n\025raw_affects_selection\030\006 \001(\010\022"
  "!\n\031raw_crop_to_playable_area\030\007 \001(\010\"\222\002\n\nP"
  "layerInfo\022\021\n\tplayer_id\030\001 \001(\r\022(\n\004type\030\002 \001"
  "(\0162\032.SC2APIProtocol.PlayerType\022,\n\016race_r"
  "equested\030\003 \001(\0162\024.SC2APIProtocol.Race\022)\n\013"
  "race_actual\030\004 \001(\0162\024.SC2APIProtocol.Race\022"
  ".\n\ndifficulty\030\005 \001(\0162\032.SC2APIProtocol.Dif"
  "ficulty\022)\n\010ai_build\030\007 \001(\0162\027.SC2APIProtoc"
  "ol.AIBuild\022\023\n\013player_name\030\006 \001(\t\"\357\001\n\014Play"
  "erCommon\022\021\n\tplayer_id\030\001 \001(\r\022\020\n\010minerals\030"
  "\002 \001(\r\022\017\n\007vespene\030\003 \001(\r\022\020\n\010food_cap\030\004 \001(\r"
  "\022\021\n\tfood_used\030\005 \001(\r\022\021\n\tfood_army\030\006 \001(\r\022\024"
  "\n\014food_workers\030\007 \001(\r\022\031\n\021idle_worker_coun"
  "t\030\010 \001(\r\022\022\n\narmy_count\030\t \001(\r\022\027\n\017warp_gate"
  "_count\030\n \001(\r\022\023\n\013larva_count\030\013 \001(\r\"\266\003\n\013Ob"
  "servation\022\021\n\tgame_loop\030\t \001(\r\0223\n\rplayer_c"
  "ommon\030\001 \001(\0132\034.SC2APIProtocol.PlayerCommo"
  "n\022%\n\006alerts\030\n \003(\0162\025.SC2APIProtocol.Alert"
  "\0223\n\tabilities\030\003 \003(\0132 .SC2APIProtocol.Ava"
  "ilableAbility\022$\n\005score\030\004 \001(\0132\025.SC2APIPro"
  "tocol.Score\0220\n\010raw_data\030\005 \001(\0132\036.SC2APIPr"
  "otocol.ObservationRaw\022C\n\022feature_layer_d"
  "ata\030\006 \001(\0132\'.SC2APIProtocol.ObservationFe"
  "atureLayer\0226\n\013render_data\030\007 \001(\0132!.SC2API"
  "Protocol.ObservationRender\022.\n\007ui_data\030\010 "
  "\001(\0132\035.SC2APIProtocol.ObservationUI\"\233\002\n\006A"
  "ction\022-\n\naction_raw\030\001 \001(\0132\031.SC2APIProtoc"
  "ol.ActionRaw\022;\n\024action_feature_layer\030\002 \001"
  "(\0132\035.SC2APIProtocol.ActionSpatial\0224\n\ract"
  "ion_render\030\003 \001(\0132\035.SC2APIProtocol.Action"
  "Spatial\022+\n\taction_ui\030\004 \001(\0132\030.SC2APIProto"
  "col.ActionUI\022/\n\013action_chat\030\006 \001(\0132\032.SC2A"
  "PIProtocol.ActionChat\022\021\n\tgame_loop\030\007 \001(\r"
  "\"v\n\nActionChat\0223\n\007channel\030\001 \001(\0162\".SC2API"
  "Protocol.ActionChat.Channel\022\017\n\007message\030\002"
  " \001(\t\"\"\n\007Channel\022\r\n\tBroadcast\020\001\022\010\n\004Team\020\002"
  "\"a\n\013ActionError\022\020\n\010unit_tag\030\001 \001(\004\022\022\n\nabi"
  "lity_id\030\002 \001(\004\022,\n\006result\030\003 \001(\0162\034.SC2APIPr"
  "otocol.ActionResult\"\314\002\n\016ObserverAction\022M"
  "\n\022player_perspective\030\001 \001(\0132/.SC2APIProto"
  "col.ActionObserverPlayerPerspectiveH\000\022\?\n"
  "\013camera_move\030\002 \001(\0132(.SC2APIProtocol.Acti"
  "onObserverCameraMoveH\000\022P\n\024camera_follow_"
  "player\030\003 \001(\01320.SC2APIProtocol.ActionObse"
  "rverCameraFollowPlayerH\000\022N\n\023camera_follo"
  "w_units\030\004 \001(\0132/.SC2APIProtocol.ActionObs"
  "erverCameraFollowUnitsH\000B\010\n\006action\"4\n\037Ac"
  "tionObserverPlayerPerspective\022\021\n\tplayer_"
  "id\030\001 \001(\r\"X\n\030ActionObserverCameraMove\022*\n\t"
  "world_pos\030\001 \001(\0132\027.SC2APIProtocol.Point2D"
  "\022\020\n\010distance\030\002 \001(\002\"5\n ActionObserverCame"
  "raFollowPlayer\022\021\n\tplayer_id\030\001 \001(\r\"4\n\037Act"
  "ionObserverCameraFollowUnits\022\021\n\tunit_tag"
  "s\030\001 \003(\004\"I\n\014PlayerResult\022\021\n\tplayer_id\030\001 \001"
  "(\r\022&\n\006result\030\002 \001(\0162\026.SC2APIProtocol.Resu"
  "lt*c\n\006Status\022\014\n\010launched\020\001\022\r\n\tinit_game\020"
  "\002\022\013\n\007in_game\020\003\022\r\n\tin_replay\020\004\022\t\n\005ended\020\005"
  "\022\010\n\004quit\020\006\022\013\n\007unknown\020c*\226\001\n\nDifficulty\022\014"
  "\n\010VeryEasy\020\001\022\010\n\004Easy\020\002\022\n\n\006Medium\020\003\022\016\n\nMe"
  "diumHard\020\004\022\010\n\004Hard\020\005\022\n\n\006Harder\020\006\022\014\n\010Very"
  "Hard\020\007\022\017\n\013CheatVision\020\010\022\016\n\nCheatMoney\020\t\022"
  "\017\n\013CheatInsane\020\n*9\n\nPlayerType\022\017\n\013Partic"
  "ipant\020\001\022\014\n\010Computer\020\002\022\014\n\010Observer\020\003*O\n\007A"
  "IBuild\022\017\n\013RandomBuild\020\001\022\010\n\004Rush\020\002\022\n\n\006Tim"
  "ing\020\003\022\t\n\005Power\020\004\022\t\n\005Macro\020\005\022\007\n\003Air\020\006*\333\003\n"
  "\005Alert\022\016\n\nAlertError\020\003\022\021\n\rAddOnComplete\020"
  "\004\022\024\n\020BuildingComplete\020\005\022\027\n\023BuildingUnder"
  "Attack\020\006\022\020\n\014LarvaHatched\020\007\022\021\n\rMergeCompl"
  "ete\020\010\022\025\n\021MineralsExhausted\020\t\022\021\n\rMorphCom"
  "plete\020\n\022\026\n\022MothershipComplete\020\013\022\017\n\013MULEE"
  "xpired\020\014\022\031\n\025NuclearLaunchDetected\020\001\022\020\n\014N"
  "ukeComplete\020\r\022\025\n\021NydusWormDetected\020\002\022\024\n\020"
  "ResearchComplete\020\016\022\016\n\nTrainError\020\017\022\025\n\021Tr"
  "ainUnitComplete\020\020\022\027\n\023TrainWorkerComplete"
  "\020\021\022\032\n\026TransformationComplete\020\022\022\023\n\017UnitUn"
  "derAttack\020\023\022\023\n\017UpgradeComplete\020\024\022\024\n\020Vesp"
  "eneExhausted\020\025\022\022\n\016WarpInComplete\020\026*9\n\006Re"
  "sult\022\013\n\007Victory\020\001\022\n\n\006Defeat\020\002\022\007\n\003Tie\020\003\022\r"
  "\n\tUndecided\020\004"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_s2clientprotocol_2fsc2api_2eproto_deps[9] = {
  &::descriptor_table_s2clientprotocol_2fcommon_2eproto,
  &::descriptor_table_s2clientprotocol_2fdata_2eproto,
  &::descriptor_table_s2clientprotocol_2fdebug_2eproto,
  &::descriptor_table_s2clientprotocol_2ferror_2eproto,
  &::descriptor_table_s2clientprotocol_2fquery_2eproto,
  &::descriptor_table_s2clientprotocol_2fraw_2eproto,
  &::descriptor_table_s2clientprotocol_2fscore_2eproto,
  &::descriptor_table_s2clientprotocol_2fspatial_2eproto,
  &::descriptor_table_s2clientprotocol_2fui_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_s2clientprotocol_2fsc2api_2eproto_sccs[63] = {
  &scc_info_Action_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ActionChat_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ActionError_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ActionObserverCameraFollowPlayer_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ActionObserverCameraFollowUnits_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ActionObserverPlayerPerspective_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ChatReceived_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_LocalMap_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_Observation_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_PlayerCommon_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_PlayerInfo_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_PlayerResult_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_PlayerSetup_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_PortSet_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_Request_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestAvailableMaps_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestData_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestGameInfo_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestLeaveGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestMapCommand_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestObservation_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestPing_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestQuickLoad_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestQuickSave_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestQuit_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestReplayInfo_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestRestartGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestSaveMap_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestSaveReplay_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_RequestStep_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_Response_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseAction_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseAvailableMaps_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseCreateGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseDebug_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseJoinGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseLeaveGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseMapCommand_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseObserverAction_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponsePing_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseQuickLoad_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseQuickSave_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseQuit_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseRestartGame_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseSaveMap_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseSaveReplay_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseStartReplay_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_ResponseStep_s2clientprotocol_2fsc2api_2eproto.base,
  &scc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_s2clientprotocol_2fsc2api_2eproto_once;
static bool descriptor_table_s2clientprotocol_2fsc2api_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_s2clientprotocol_2fsc2api_2eproto = {
  &descriptor_table_s2clientprotocol_2fsc2api_2eproto_initialized, descriptor_table_protodef_s2clientprotocol_2fsc2api_2eproto, "s2clientprotocol/sc2api.proto", 11413,
  &descriptor_table_s2clientprotocol_2fsc2api_2eproto_once, descriptor_table_s2clientprotocol_2fsc2api_2eproto_sccs, descriptor_table_s2clientprotocol_2fsc2api_2eproto_deps, 63, 9,
  schemas, file_default_instances, TableStruct_s2clientprotocol_2fsc2api_2eproto::offsets,
  file_level_metadata_s2clientprotocol_2fsc2api_2eproto, 63, file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto, file_level_service_descriptors_s2clientprotocol_2fsc2api_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_s2clientprotocol_2fsc2api_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto)), true);
namespace SC2APIProtocol {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseCreateGame_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[0];
}
bool ResponseCreateGame_Error_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseCreateGame_Error ResponseCreateGame::MissingMap;
constexpr ResponseCreateGame_Error ResponseCreateGame::InvalidMapPath;
constexpr ResponseCreateGame_Error ResponseCreateGame::InvalidMapData;
constexpr ResponseCreateGame_Error ResponseCreateGame::InvalidMapName;
constexpr ResponseCreateGame_Error ResponseCreateGame::InvalidMapHandle;
constexpr ResponseCreateGame_Error ResponseCreateGame::MissingPlayerSetup;
constexpr ResponseCreateGame_Error ResponseCreateGame::InvalidPlayerSetup;
constexpr ResponseCreateGame_Error ResponseCreateGame::MultiplayerUnsupported;
constexpr ResponseCreateGame_Error ResponseCreateGame::Error_MIN;
constexpr ResponseCreateGame_Error ResponseCreateGame::Error_MAX;
constexpr int ResponseCreateGame::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseJoinGame_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[1];
}
bool ResponseJoinGame_Error_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:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseJoinGame_Error ResponseJoinGame::MissingParticipation;
constexpr ResponseJoinGame_Error ResponseJoinGame::InvalidObservedPlayerId;
constexpr ResponseJoinGame_Error ResponseJoinGame::MissingOptions;
constexpr ResponseJoinGame_Error ResponseJoinGame::MissingPorts;
constexpr ResponseJoinGame_Error ResponseJoinGame::GameFull;
constexpr ResponseJoinGame_Error ResponseJoinGame::LaunchError;
constexpr ResponseJoinGame_Error ResponseJoinGame::FeatureUnsupported;
constexpr ResponseJoinGame_Error ResponseJoinGame::NoSpaceForUser;
constexpr ResponseJoinGame_Error ResponseJoinGame::MapDoesNotExist;
constexpr ResponseJoinGame_Error ResponseJoinGame::CannotOpenMap;
constexpr ResponseJoinGame_Error ResponseJoinGame::ChecksumError;
constexpr ResponseJoinGame_Error ResponseJoinGame::NetworkError;
constexpr ResponseJoinGame_Error ResponseJoinGame::OtherError;
constexpr ResponseJoinGame_Error ResponseJoinGame::Error_MIN;
constexpr ResponseJoinGame_Error ResponseJoinGame::Error_MAX;
constexpr int ResponseJoinGame::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseRestartGame_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[2];
}
bool ResponseRestartGame_Error_IsValid(int value) {
  switch (value) {
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseRestartGame_Error ResponseRestartGame::LaunchError;
constexpr ResponseRestartGame_Error ResponseRestartGame::Error_MIN;
constexpr ResponseRestartGame_Error ResponseRestartGame::Error_MAX;
constexpr int ResponseRestartGame::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseStartReplay_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[3];
}
bool ResponseStartReplay_Error_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseStartReplay_Error ResponseStartReplay::MissingReplay;
constexpr ResponseStartReplay_Error ResponseStartReplay::InvalidReplayPath;
constexpr ResponseStartReplay_Error ResponseStartReplay::InvalidReplayData;
constexpr ResponseStartReplay_Error ResponseStartReplay::InvalidMapData;
constexpr ResponseStartReplay_Error ResponseStartReplay::InvalidObservedPlayerId;
constexpr ResponseStartReplay_Error ResponseStartReplay::MissingOptions;
constexpr ResponseStartReplay_Error ResponseStartReplay::LaunchError;
constexpr ResponseStartReplay_Error ResponseStartReplay::Error_MIN;
constexpr ResponseStartReplay_Error ResponseStartReplay::Error_MAX;
constexpr int ResponseStartReplay::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseMapCommand_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[4];
}
bool ResponseMapCommand_Error_IsValid(int value) {
  switch (value) {
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseMapCommand_Error ResponseMapCommand::NoTriggerError;
constexpr ResponseMapCommand_Error ResponseMapCommand::Error_MIN;
constexpr ResponseMapCommand_Error ResponseMapCommand::Error_MAX;
constexpr int ResponseMapCommand::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseReplayInfo_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[5];
}
bool ResponseReplayInfo_Error_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseReplayInfo_Error ResponseReplayInfo::MissingReplay;
constexpr ResponseReplayInfo_Error ResponseReplayInfo::InvalidReplayPath;
constexpr ResponseReplayInfo_Error ResponseReplayInfo::InvalidReplayData;
constexpr ResponseReplayInfo_Error ResponseReplayInfo::ParsingError;
constexpr ResponseReplayInfo_Error ResponseReplayInfo::DownloadError;
constexpr ResponseReplayInfo_Error ResponseReplayInfo::Error_MIN;
constexpr ResponseReplayInfo_Error ResponseReplayInfo::Error_MAX;
constexpr int ResponseReplayInfo::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ResponseSaveMap_Error_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[6];
}
bool ResponseSaveMap_Error_IsValid(int value) {
  switch (value) {
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ResponseSaveMap_Error ResponseSaveMap::InvalidMapData;
constexpr ResponseSaveMap_Error ResponseSaveMap::Error_MIN;
constexpr ResponseSaveMap_Error ResponseSaveMap::Error_MAX;
constexpr int ResponseSaveMap::Error_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ActionChat_Channel_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[7];
}
bool ActionChat_Channel_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ActionChat_Channel ActionChat::Broadcast;
constexpr ActionChat_Channel ActionChat::Team;
constexpr ActionChat_Channel ActionChat::Channel_MIN;
constexpr ActionChat_Channel ActionChat::Channel_MAX;
constexpr int ActionChat::Channel_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Status_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[8];
}
bool Status_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 99:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Difficulty_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[9];
}
bool Difficulty_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:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayerType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[10];
}
bool PlayerType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AIBuild_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[11];
}
bool AIBuild_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Alert_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[12];
}
bool Alert_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:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Result_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fsc2api_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fsc2api_2eproto[13];
}
bool Result_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

void Request::InitAsDefaultInstance() {
  ::SC2APIProtocol::_Request_default_instance_.create_game_ = const_cast< ::SC2APIProtocol::RequestCreateGame*>(
      ::SC2APIProtocol::RequestCreateGame::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.join_game_ = const_cast< ::SC2APIProtocol::RequestJoinGame*>(
      ::SC2APIProtocol::RequestJoinGame::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.restart_game_ = const_cast< ::SC2APIProtocol::RequestRestartGame*>(
      ::SC2APIProtocol::RequestRestartGame::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.start_replay_ = const_cast< ::SC2APIProtocol::RequestStartReplay*>(
      ::SC2APIProtocol::RequestStartReplay::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.leave_game_ = const_cast< ::SC2APIProtocol::RequestLeaveGame*>(
      ::SC2APIProtocol::RequestLeaveGame::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.quick_save_ = const_cast< ::SC2APIProtocol::RequestQuickSave*>(
      ::SC2APIProtocol::RequestQuickSave::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.quick_load_ = const_cast< ::SC2APIProtocol::RequestQuickLoad*>(
      ::SC2APIProtocol::RequestQuickLoad::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.quit_ = const_cast< ::SC2APIProtocol::RequestQuit*>(
      ::SC2APIProtocol::RequestQuit::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.game_info_ = const_cast< ::SC2APIProtocol::RequestGameInfo*>(
      ::SC2APIProtocol::RequestGameInfo::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.observation_ = const_cast< ::SC2APIProtocol::RequestObservation*>(
      ::SC2APIProtocol::RequestObservation::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.action_ = const_cast< ::SC2APIProtocol::RequestAction*>(
      ::SC2APIProtocol::RequestAction::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.obs_action_ = const_cast< ::SC2APIProtocol::RequestObserverAction*>(
      ::SC2APIProtocol::RequestObserverAction::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.step_ = const_cast< ::SC2APIProtocol::RequestStep*>(
      ::SC2APIProtocol::RequestStep::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.data_ = const_cast< ::SC2APIProtocol::RequestData*>(
      ::SC2APIProtocol::RequestData::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.query_ = const_cast< ::SC2APIProtocol::RequestQuery*>(
      ::SC2APIProtocol::RequestQuery::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.save_replay_ = const_cast< ::SC2APIProtocol::RequestSaveReplay*>(
      ::SC2APIProtocol::RequestSaveReplay::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.map_command_ = const_cast< ::SC2APIProtocol::RequestMapCommand*>(
      ::SC2APIProtocol::RequestMapCommand::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.replay_info_ = const_cast< ::SC2APIProtocol::RequestReplayInfo*>(
      ::SC2APIProtocol::RequestReplayInfo::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.available_maps_ = const_cast< ::SC2APIProtocol::RequestAvailableMaps*>(
      ::SC2APIProtocol::RequestAvailableMaps::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.save_map_ = const_cast< ::SC2APIProtocol::RequestSaveMap*>(
      ::SC2APIProtocol::RequestSaveMap::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.ping_ = const_cast< ::SC2APIProtocol::RequestPing*>(
      ::SC2APIProtocol::RequestPing::internal_default_instance());
  ::SC2APIProtocol::_Request_default_instance_.debug_ = const_cast< ::SC2APIProtocol::RequestDebug*>(
      ::SC2APIProtocol::RequestDebug::internal_default_instance());
}
class Request::_Internal {
 public:
  using HasBits = decltype(std::declval<Request>()._has_bits_);
  static const ::SC2APIProtocol::RequestCreateGame& create_game(const Request* msg);
  static const ::SC2APIProtocol::RequestJoinGame& join_game(const Request* msg);
  static const ::SC2APIProtocol::RequestRestartGame& restart_game(const Request* msg);
  static const ::SC2APIProtocol::RequestStartReplay& start_replay(const Request* msg);
  static const ::SC2APIProtocol::RequestLeaveGame& leave_game(const Request* msg);
  static const ::SC2APIProtocol::RequestQuickSave& quick_save(const Request* msg);
  static const ::SC2APIProtocol::RequestQuickLoad& quick_load(const Request* msg);
  static const ::SC2APIProtocol::RequestQuit& quit(const Request* msg);
  static const ::SC2APIProtocol::RequestGameInfo& game_info(const Request* msg);
  static const ::SC2APIProtocol::RequestObservation& observation(const Request* msg);
  static const ::SC2APIProtocol::RequestAction& action(const Request* msg);
  static const ::SC2APIProtocol::RequestObserverAction& obs_action(const Request* msg);
  static const ::SC2APIProtocol::RequestStep& step(const Request* msg);
  static const ::SC2APIProtocol::RequestData& data(const Request* msg);
  static const ::SC2APIProtocol::RequestQuery& query(const Request* msg);
  static const ::SC2APIProtocol::RequestSaveReplay& save_replay(const Request* msg);
  static const ::SC2APIProtocol::RequestMapCommand& map_command(const Request* msg);
  static const ::SC2APIProtocol::RequestReplayInfo& replay_info(const Request* msg);
  static const ::SC2APIProtocol::RequestAvailableMaps& available_maps(const Request* msg);
  static const ::SC2APIProtocol::RequestSaveMap& save_map(const Request* msg);
  static const ::SC2APIProtocol::RequestPing& ping(const Request* msg);
  static const ::SC2APIProtocol::RequestDebug& debug(const Request* msg);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SC2APIProtocol::RequestCreateGame&
Request::_Internal::create_game(const Request* msg) {
  return *msg->request_.create_game_;
}
const ::SC2APIProtocol::RequestJoinGame&
Request::_Internal::join_game(const Request* msg) {
  return *msg->request_.join_game_;
}
const ::SC2APIProtocol::RequestRestartGame&
Request::_Internal::restart_game(const Request* msg) {
  return *msg->request_.restart_game_;
}
const ::SC2APIProtocol::RequestStartReplay&
Request::_Internal::start_replay(const Request* msg) {
  return *msg->request_.start_replay_;
}
const ::SC2APIProtocol::RequestLeaveGame&
Request::_Internal::leave_game(const Request* msg) {
  return *msg->request_.leave_game_;
}
const ::SC2APIProtocol::RequestQuickSave&
Request::_Internal::quick_save(const Request* msg) {
  return *msg->request_.quick_save_;
}
const ::SC2APIProtocol::RequestQuickLoad&
Request::_Internal::quick_load(const Request* msg) {
  return *msg->request_.quick_load_;
}
const ::SC2APIProtocol::RequestQuit&
Request::_Internal::quit(const Request* msg) {
  return *msg->request_.quit_;
}
const ::SC2APIProtocol::RequestGameInfo&
Request::_Internal::game_info(const Request* msg) {
  return *msg->request_.game_info_;
}
const ::SC2APIProtocol::RequestObservation&
Request::_Internal::observation(const Request* msg) {
  return *msg->request_.observation_;
}
const ::SC2APIProtocol::RequestAction&
Request::_Internal::action(const Request* msg) {
  return *msg->request_.action_;
}
const ::SC2APIProtocol::RequestObserverAction&
Request::_Internal::obs_action(const Request* msg) {
  return *msg->request_.obs_action_;
}
const ::SC2APIProtocol::RequestStep&
Request::_Internal::step(const Request* msg) {
  return *msg->request_.step_;
}
const ::SC2APIProtocol::RequestData&
Request::_Internal::data(const Request* msg) {
  return *msg->request_.data_;
}
const ::SC2APIProtocol::RequestQuery&
Request::_Internal::query(const Request* msg) {
  return *msg->request_.query_;
}
const ::SC2APIProtocol::RequestSaveReplay&
Request::_Internal::save_replay(const Request* msg) {
  return *msg->request_.save_replay_;
}
const ::SC2APIProtocol::RequestMapCommand&
Request::_Internal::map_command(const Request* msg) {
  return *msg->request_.map_command_;
}
const ::SC2APIProtocol::RequestReplayInfo&
Request::_Internal::replay_info(const Request* msg) {
  return *msg->request_.replay_info_;
}
const ::SC2APIProtocol::RequestAvailableMaps&
Request::_Internal::available_maps(const Request* msg) {
  return *msg->request_.available_maps_;
}
const ::SC2APIProtocol::RequestSaveMap&
Request::_Internal::save_map(const Request* msg) {
  return *msg->request_.save_map_;
}
const ::SC2APIProtocol::RequestPing&
Request::_Internal::ping(const Request* msg) {
  return *msg->request_.ping_;
}
const ::SC2APIProtocol::RequestDebug&
Request::_Internal::debug(const Request* msg) {
  return *msg->request_.debug_;
}
void Request::set_allocated_create_game(::SC2APIProtocol::RequestCreateGame* create_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (create_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      create_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_game, submessage_arena);
    }
    set_has_create_game();
    request_.create_game_ = create_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.create_game)
}
void Request::set_allocated_join_game(::SC2APIProtocol::RequestJoinGame* join_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (join_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      join_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, join_game, submessage_arena);
    }
    set_has_join_game();
    request_.join_game_ = join_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.join_game)
}
void Request::set_allocated_restart_game(::SC2APIProtocol::RequestRestartGame* restart_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (restart_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      restart_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, restart_game, submessage_arena);
    }
    set_has_restart_game();
    request_.restart_game_ = restart_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.restart_game)
}
void Request::set_allocated_start_replay(::SC2APIProtocol::RequestStartReplay* start_replay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (start_replay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      start_replay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start_replay, submessage_arena);
    }
    set_has_start_replay();
    request_.start_replay_ = start_replay;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.start_replay)
}
void Request::set_allocated_leave_game(::SC2APIProtocol::RequestLeaveGame* leave_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (leave_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      leave_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, leave_game, submessage_arena);
    }
    set_has_leave_game();
    request_.leave_game_ = leave_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.leave_game)
}
void Request::set_allocated_quick_save(::SC2APIProtocol::RequestQuickSave* quick_save) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (quick_save) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      quick_save = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quick_save, submessage_arena);
    }
    set_has_quick_save();
    request_.quick_save_ = quick_save;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.quick_save)
}
void Request::set_allocated_quick_load(::SC2APIProtocol::RequestQuickLoad* quick_load) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (quick_load) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      quick_load = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quick_load, submessage_arena);
    }
    set_has_quick_load();
    request_.quick_load_ = quick_load;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.quick_load)
}
void Request::set_allocated_quit(::SC2APIProtocol::RequestQuit* quit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (quit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      quit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quit, submessage_arena);
    }
    set_has_quit();
    request_.quit_ = quit;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.quit)
}
void Request::set_allocated_game_info(::SC2APIProtocol::RequestGameInfo* game_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (game_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      game_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, game_info, submessage_arena);
    }
    set_has_game_info();
    request_.game_info_ = game_info;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.game_info)
}
void Request::set_allocated_observation(::SC2APIProtocol::RequestObservation* observation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (observation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      observation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, observation, submessage_arena);
    }
    set_has_observation();
    request_.observation_ = observation;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.observation)
}
void Request::set_allocated_action(::SC2APIProtocol::RequestAction* action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, action, submessage_arena);
    }
    set_has_action();
    request_.action_ = action;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.action)
}
void Request::set_allocated_obs_action(::SC2APIProtocol::RequestObserverAction* obs_action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (obs_action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      obs_action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, obs_action, submessage_arena);
    }
    set_has_obs_action();
    request_.obs_action_ = obs_action;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.obs_action)
}
void Request::set_allocated_step(::SC2APIProtocol::RequestStep* step) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (step) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      step = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, step, submessage_arena);
    }
    set_has_step();
    request_.step_ = step;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.step)
}
void Request::set_allocated_data(::SC2APIProtocol::RequestData* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    request_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.data)
}
void Request::set_allocated_query(::SC2APIProtocol::RequestQuery* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    set_has_query();
    request_.query_ = query;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.query)
}
void Request::clear_query() {
  if (_internal_has_query()) {
    delete request_.query_;
    clear_has_request();
  }
}
void Request::set_allocated_save_replay(::SC2APIProtocol::RequestSaveReplay* save_replay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (save_replay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      save_replay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, save_replay, submessage_arena);
    }
    set_has_save_replay();
    request_.save_replay_ = save_replay;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.save_replay)
}
void Request::set_allocated_map_command(::SC2APIProtocol::RequestMapCommand* map_command) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (map_command) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      map_command = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, map_command, submessage_arena);
    }
    set_has_map_command();
    request_.map_command_ = map_command;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.map_command)
}
void Request::set_allocated_replay_info(::SC2APIProtocol::RequestReplayInfo* replay_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (replay_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      replay_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, replay_info, submessage_arena);
    }
    set_has_replay_info();
    request_.replay_info_ = replay_info;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.replay_info)
}
void Request::set_allocated_available_maps(::SC2APIProtocol::RequestAvailableMaps* available_maps) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (available_maps) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      available_maps = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, available_maps, submessage_arena);
    }
    set_has_available_maps();
    request_.available_maps_ = available_maps;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.available_maps)
}
void Request::set_allocated_save_map(::SC2APIProtocol::RequestSaveMap* save_map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (save_map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      save_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, save_map, submessage_arena);
    }
    set_has_save_map();
    request_.save_map_ = save_map;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.save_map)
}
void Request::set_allocated_ping(::SC2APIProtocol::RequestPing* ping) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (ping) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      ping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ping, submessage_arena);
    }
    set_has_ping();
    request_.ping_ = ping;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.ping)
}
void Request::set_allocated_debug(::SC2APIProtocol::RequestDebug* debug) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (debug) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      debug = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, debug, submessage_arena);
    }
    set_has_debug();
    request_.debug_ = debug;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Request.debug)
}
Request::Request()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.Request)
}
Request::Request(const Request& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_ = from.id_;
  clear_has_request();
  switch (from.request_case()) {
    case kCreateGame: {
      _internal_mutable_create_game()->::SC2APIProtocol::RequestCreateGame::MergeFrom(from._internal_create_game());
      break;
    }
    case kJoinGame: {
      _internal_mutable_join_game()->::SC2APIProtocol::RequestJoinGame::MergeFrom(from._internal_join_game());
      break;
    }
    case kRestartGame: {
      _internal_mutable_restart_game()->::SC2APIProtocol::RequestRestartGame::MergeFrom(from._internal_restart_game());
      break;
    }
    case kStartReplay: {
      _internal_mutable_start_replay()->::SC2APIProtocol::RequestStartReplay::MergeFrom(from._internal_start_replay());
      break;
    }
    case kLeaveGame: {
      _internal_mutable_leave_game()->::SC2APIProtocol::RequestLeaveGame::MergeFrom(from._internal_leave_game());
      break;
    }
    case kQuickSave: {
      _internal_mutable_quick_save()->::SC2APIProtocol::RequestQuickSave::MergeFrom(from._internal_quick_save());
      break;
    }
    case kQuickLoad: {
      _internal_mutable_quick_load()->::SC2APIProtocol::RequestQuickLoad::MergeFrom(from._internal_quick_load());
      break;
    }
    case kQuit: {
      _internal_mutable_quit()->::SC2APIProtocol::RequestQuit::MergeFrom(from._internal_quit());
      break;
    }
    case kGameInfo: {
      _internal_mutable_game_info()->::SC2APIProtocol::RequestGameInfo::MergeFrom(from._internal_game_info());
      break;
    }
    case kObservation: {
      _internal_mutable_observation()->::SC2APIProtocol::RequestObservation::MergeFrom(from._internal_observation());
      break;
    }
    case kAction: {
      _internal_mutable_action()->::SC2APIProtocol::RequestAction::MergeFrom(from._internal_action());
      break;
    }
    case kObsAction: {
      _internal_mutable_obs_action()->::SC2APIProtocol::RequestObserverAction::MergeFrom(from._internal_obs_action());
      break;
    }
    case kStep: {
      _internal_mutable_step()->::SC2APIProtocol::RequestStep::MergeFrom(from._internal_step());
      break;
    }
    case kData: {
      _internal_mutable_data()->::SC2APIProtocol::RequestData::MergeFrom(from._internal_data());
      break;
    }
    case kQuery: {
      _internal_mutable_query()->::SC2APIProtocol::RequestQuery::MergeFrom(from._internal_query());
      break;
    }
    case kSaveReplay: {
      _internal_mutable_save_replay()->::SC2APIProtocol::RequestSaveReplay::MergeFrom(from._internal_save_replay());
      break;
    }
    case kMapCommand: {
      _internal_mutable_map_command()->::SC2APIProtocol::RequestMapCommand::MergeFrom(from._internal_map_command());
      break;
    }
    case kReplayInfo: {
      _internal_mutable_replay_info()->::SC2APIProtocol::RequestReplayInfo::MergeFrom(from._internal_replay_info());
      break;
    }
    case kAvailableMaps: {
      _internal_mutable_available_maps()->::SC2APIProtocol::RequestAvailableMaps::MergeFrom(from._internal_available_maps());
      break;
    }
    case kSaveMap: {
      _internal_mutable_save_map()->::SC2APIProtocol::RequestSaveMap::MergeFrom(from._internal_save_map());
      break;
    }
    case kPing: {
      _internal_mutable_ping()->::SC2APIProtocol::RequestPing::MergeFrom(from._internal_ping());
      break;
    }
    case kDebug: {
      _internal_mutable_debug()->::SC2APIProtocol::RequestDebug::MergeFrom(from._internal_debug());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.Request)
}

void Request::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Request_s2clientprotocol_2fsc2api_2eproto.base);
  id_ = 0u;
  clear_has_request();
}

Request::~Request() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.Request)
  SharedDtor();
}

void Request::SharedDtor() {
  if (has_request()) {
    clear_request();
  }
}

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


void Request::clear_request() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.Request)
  switch (request_case()) {
    case kCreateGame: {
      delete request_.create_game_;
      break;
    }
    case kJoinGame: {
      delete request_.join_game_;
      break;
    }
    case kRestartGame: {
      delete request_.restart_game_;
      break;
    }
    case kStartReplay: {
      delete request_.start_replay_;
      break;
    }
    case kLeaveGame: {
      delete request_.leave_game_;
      break;
    }
    case kQuickSave: {
      delete request_.quick_save_;
      break;
    }
    case kQuickLoad: {
      delete request_.quick_load_;
      break;
    }
    case kQuit: {
      delete request_.quit_;
      break;
    }
    case kGameInfo: {
      delete request_.game_info_;
      break;
    }
    case kObservation: {
      delete request_.observation_;
      break;
    }
    case kAction: {
      delete request_.action_;
      break;
    }
    case kObsAction: {
      delete request_.obs_action_;
      break;
    }
    case kStep: {
      delete request_.step_;
      break;
    }
    case kData: {
      delete request_.data_;
      break;
    }
    case kQuery: {
      delete request_.query_;
      break;
    }
    case kSaveReplay: {
      delete request_.save_replay_;
      break;
    }
    case kMapCommand: {
      delete request_.map_command_;
      break;
    }
    case kReplayInfo: {
      delete request_.replay_info_;
      break;
    }
    case kAvailableMaps: {
      delete request_.available_maps_;
      break;
    }
    case kSaveMap: {
      delete request_.save_map_;
      break;
    }
    case kPing: {
      delete request_.ping_;
      break;
    }
    case kDebug: {
      delete request_.debug_;
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REQUEST_NOT_SET;
}


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

  id_ = 0u;
  clear_request();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.RequestCreateGame create_game = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_create_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestJoinGame join_game = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_join_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestRestartGame restart_game = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_restart_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestStartReplay start_replay = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_start_replay(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestLeaveGame leave_game = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_leave_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestQuickSave quick_save = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_quick_save(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestQuickLoad quick_load = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_quick_load(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestQuit quit = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_quit(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestGameInfo game_info = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_game_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestObservation observation = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_observation(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestAction action = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_action(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestStep step = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_step(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestData data = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestQuery query = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_query(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestSaveReplay save_replay = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_save_replay(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestReplayInfo replay_info = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_replay_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestAvailableMaps available_maps = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_available_maps(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestSaveMap save_map = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_save_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestPing ping = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_ping(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestDebug debug = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_debug(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestObserverAction obs_action = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_obs_action(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.RequestMapCommand map_command = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_map_command(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 id = 97;
      case 97:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  switch (request_case()) {
    case kCreateGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::create_game(this), target, stream);
      break;
    }
    case kJoinGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::join_game(this), target, stream);
      break;
    }
    case kRestartGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::restart_game(this), target, stream);
      break;
    }
    case kStartReplay: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::start_replay(this), target, stream);
      break;
    }
    case kLeaveGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::leave_game(this), target, stream);
      break;
    }
    case kQuickSave: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::quick_save(this), target, stream);
      break;
    }
    case kQuickLoad: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::quick_load(this), target, stream);
      break;
    }
    case kQuit: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          8, _Internal::quit(this), target, stream);
      break;
    }
    case kGameInfo: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          9, _Internal::game_info(this), target, stream);
      break;
    }
    case kObservation: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          10, _Internal::observation(this), target, stream);
      break;
    }
    case kAction: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          11, _Internal::action(this), target, stream);
      break;
    }
    case kStep: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          12, _Internal::step(this), target, stream);
      break;
    }
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          13, _Internal::data(this), target, stream);
      break;
    }
    case kQuery: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          14, _Internal::query(this), target, stream);
      break;
    }
    case kSaveReplay: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          15, _Internal::save_replay(this), target, stream);
      break;
    }
    case kReplayInfo: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          16, _Internal::replay_info(this), target, stream);
      break;
    }
    case kAvailableMaps: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          17, _Internal::available_maps(this), target, stream);
      break;
    }
    case kSaveMap: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          18, _Internal::save_map(this), target, stream);
      break;
    }
    case kPing: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          19, _Internal::ping(this), target, stream);
      break;
    }
    case kDebug: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          20, _Internal::debug(this), target, stream);
      break;
    }
    case kObsAction: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          21, _Internal::obs_action(this), target, stream);
      break;
    }
    case kMapCommand: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          22, _Internal::map_command(this), target, stream);
      break;
    }
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional uint32 id = 97;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(97, this->_internal_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.Request)
  return target;
}

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

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

  // optional uint32 id = 97;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 2 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_id());
  }

  switch (request_case()) {
    // optional .SC2APIProtocol.RequestCreateGame create_game = 1;
    case kCreateGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.create_game_);
      break;
    }
    // optional .SC2APIProtocol.RequestJoinGame join_game = 2;
    case kJoinGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.join_game_);
      break;
    }
    // optional .SC2APIProtocol.RequestRestartGame restart_game = 3;
    case kRestartGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.restart_game_);
      break;
    }
    // optional .SC2APIProtocol.RequestStartReplay start_replay = 4;
    case kStartReplay: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.start_replay_);
      break;
    }
    // optional .SC2APIProtocol.RequestLeaveGame leave_game = 5;
    case kLeaveGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.leave_game_);
      break;
    }
    // optional .SC2APIProtocol.RequestQuickSave quick_save = 6;
    case kQuickSave: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.quick_save_);
      break;
    }
    // optional .SC2APIProtocol.RequestQuickLoad quick_load = 7;
    case kQuickLoad: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.quick_load_);
      break;
    }
    // optional .SC2APIProtocol.RequestQuit quit = 8;
    case kQuit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.quit_);
      break;
    }
    // optional .SC2APIProtocol.RequestGameInfo game_info = 9;
    case kGameInfo: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.game_info_);
      break;
    }
    // optional .SC2APIProtocol.RequestObservation observation = 10;
    case kObservation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.observation_);
      break;
    }
    // optional .SC2APIProtocol.RequestAction action = 11;
    case kAction: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.action_);
      break;
    }
    // optional .SC2APIProtocol.RequestObserverAction obs_action = 21;
    case kObsAction: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.obs_action_);
      break;
    }
    // optional .SC2APIProtocol.RequestStep step = 12;
    case kStep: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.step_);
      break;
    }
    // optional .SC2APIProtocol.RequestData data = 13;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.data_);
      break;
    }
    // optional .SC2APIProtocol.RequestQuery query = 14;
    case kQuery: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.query_);
      break;
    }
    // optional .SC2APIProtocol.RequestSaveReplay save_replay = 15;
    case kSaveReplay: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.save_replay_);
      break;
    }
    // optional .SC2APIProtocol.RequestMapCommand map_command = 22;
    case kMapCommand: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.map_command_);
      break;
    }
    // optional .SC2APIProtocol.RequestReplayInfo replay_info = 16;
    case kReplayInfo: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.replay_info_);
      break;
    }
    // optional .SC2APIProtocol.RequestAvailableMaps available_maps = 17;
    case kAvailableMaps: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.available_maps_);
      break;
    }
    // optional .SC2APIProtocol.RequestSaveMap save_map = 18;
    case kSaveMap: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.save_map_);
      break;
    }
    // optional .SC2APIProtocol.RequestPing ping = 19;
    case kPing: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.ping_);
      break;
    }
    // optional .SC2APIProtocol.RequestDebug debug = 20;
    case kDebug: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.debug_);
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  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 Request::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.Request)
  GOOGLE_DCHECK_NE(&from, this);
  const Request* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Request>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.Request)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.Request)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_id()) {
    _internal_set_id(from._internal_id());
  }
  switch (from.request_case()) {
    case kCreateGame: {
      _internal_mutable_create_game()->::SC2APIProtocol::RequestCreateGame::MergeFrom(from._internal_create_game());
      break;
    }
    case kJoinGame: {
      _internal_mutable_join_game()->::SC2APIProtocol::RequestJoinGame::MergeFrom(from._internal_join_game());
      break;
    }
    case kRestartGame: {
      _internal_mutable_restart_game()->::SC2APIProtocol::RequestRestartGame::MergeFrom(from._internal_restart_game());
      break;
    }
    case kStartReplay: {
      _internal_mutable_start_replay()->::SC2APIProtocol::RequestStartReplay::MergeFrom(from._internal_start_replay());
      break;
    }
    case kLeaveGame: {
      _internal_mutable_leave_game()->::SC2APIProtocol::RequestLeaveGame::MergeFrom(from._internal_leave_game());
      break;
    }
    case kQuickSave: {
      _internal_mutable_quick_save()->::SC2APIProtocol::RequestQuickSave::MergeFrom(from._internal_quick_save());
      break;
    }
    case kQuickLoad: {
      _internal_mutable_quick_load()->::SC2APIProtocol::RequestQuickLoad::MergeFrom(from._internal_quick_load());
      break;
    }
    case kQuit: {
      _internal_mutable_quit()->::SC2APIProtocol::RequestQuit::MergeFrom(from._internal_quit());
      break;
    }
    case kGameInfo: {
      _internal_mutable_game_info()->::SC2APIProtocol::RequestGameInfo::MergeFrom(from._internal_game_info());
      break;
    }
    case kObservation: {
      _internal_mutable_observation()->::SC2APIProtocol::RequestObservation::MergeFrom(from._internal_observation());
      break;
    }
    case kAction: {
      _internal_mutable_action()->::SC2APIProtocol::RequestAction::MergeFrom(from._internal_action());
      break;
    }
    case kObsAction: {
      _internal_mutable_obs_action()->::SC2APIProtocol::RequestObserverAction::MergeFrom(from._internal_obs_action());
      break;
    }
    case kStep: {
      _internal_mutable_step()->::SC2APIProtocol::RequestStep::MergeFrom(from._internal_step());
      break;
    }
    case kData: {
      _internal_mutable_data()->::SC2APIProtocol::RequestData::MergeFrom(from._internal_data());
      break;
    }
    case kQuery: {
      _internal_mutable_query()->::SC2APIProtocol::RequestQuery::MergeFrom(from._internal_query());
      break;
    }
    case kSaveReplay: {
      _internal_mutable_save_replay()->::SC2APIProtocol::RequestSaveReplay::MergeFrom(from._internal_save_replay());
      break;
    }
    case kMapCommand: {
      _internal_mutable_map_command()->::SC2APIProtocol::RequestMapCommand::MergeFrom(from._internal_map_command());
      break;
    }
    case kReplayInfo: {
      _internal_mutable_replay_info()->::SC2APIProtocol::RequestReplayInfo::MergeFrom(from._internal_replay_info());
      break;
    }
    case kAvailableMaps: {
      _internal_mutable_available_maps()->::SC2APIProtocol::RequestAvailableMaps::MergeFrom(from._internal_available_maps());
      break;
    }
    case kSaveMap: {
      _internal_mutable_save_map()->::SC2APIProtocol::RequestSaveMap::MergeFrom(from._internal_save_map());
      break;
    }
    case kPing: {
      _internal_mutable_ping()->::SC2APIProtocol::RequestPing::MergeFrom(from._internal_ping());
      break;
    }
    case kDebug: {
      _internal_mutable_debug()->::SC2APIProtocol::RequestDebug::MergeFrom(from._internal_debug());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
}

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

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

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

void Request::InternalSwap(Request* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(id_, other->id_);
  swap(request_, other->request_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void Response::InitAsDefaultInstance() {
  ::SC2APIProtocol::_Response_default_instance_.create_game_ = const_cast< ::SC2APIProtocol::ResponseCreateGame*>(
      ::SC2APIProtocol::ResponseCreateGame::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.join_game_ = const_cast< ::SC2APIProtocol::ResponseJoinGame*>(
      ::SC2APIProtocol::ResponseJoinGame::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.restart_game_ = const_cast< ::SC2APIProtocol::ResponseRestartGame*>(
      ::SC2APIProtocol::ResponseRestartGame::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.start_replay_ = const_cast< ::SC2APIProtocol::ResponseStartReplay*>(
      ::SC2APIProtocol::ResponseStartReplay::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.leave_game_ = const_cast< ::SC2APIProtocol::ResponseLeaveGame*>(
      ::SC2APIProtocol::ResponseLeaveGame::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.quick_save_ = const_cast< ::SC2APIProtocol::ResponseQuickSave*>(
      ::SC2APIProtocol::ResponseQuickSave::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.quick_load_ = const_cast< ::SC2APIProtocol::ResponseQuickLoad*>(
      ::SC2APIProtocol::ResponseQuickLoad::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.quit_ = const_cast< ::SC2APIProtocol::ResponseQuit*>(
      ::SC2APIProtocol::ResponseQuit::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.game_info_ = const_cast< ::SC2APIProtocol::ResponseGameInfo*>(
      ::SC2APIProtocol::ResponseGameInfo::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.observation_ = const_cast< ::SC2APIProtocol::ResponseObservation*>(
      ::SC2APIProtocol::ResponseObservation::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.action_ = const_cast< ::SC2APIProtocol::ResponseAction*>(
      ::SC2APIProtocol::ResponseAction::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.obs_action_ = const_cast< ::SC2APIProtocol::ResponseObserverAction*>(
      ::SC2APIProtocol::ResponseObserverAction::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.step_ = const_cast< ::SC2APIProtocol::ResponseStep*>(
      ::SC2APIProtocol::ResponseStep::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.data_ = const_cast< ::SC2APIProtocol::ResponseData*>(
      ::SC2APIProtocol::ResponseData::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.query_ = const_cast< ::SC2APIProtocol::ResponseQuery*>(
      ::SC2APIProtocol::ResponseQuery::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.save_replay_ = const_cast< ::SC2APIProtocol::ResponseSaveReplay*>(
      ::SC2APIProtocol::ResponseSaveReplay::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.replay_info_ = const_cast< ::SC2APIProtocol::ResponseReplayInfo*>(
      ::SC2APIProtocol::ResponseReplayInfo::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.available_maps_ = const_cast< ::SC2APIProtocol::ResponseAvailableMaps*>(
      ::SC2APIProtocol::ResponseAvailableMaps::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.save_map_ = const_cast< ::SC2APIProtocol::ResponseSaveMap*>(
      ::SC2APIProtocol::ResponseSaveMap::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.map_command_ = const_cast< ::SC2APIProtocol::ResponseMapCommand*>(
      ::SC2APIProtocol::ResponseMapCommand::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.ping_ = const_cast< ::SC2APIProtocol::ResponsePing*>(
      ::SC2APIProtocol::ResponsePing::internal_default_instance());
  ::SC2APIProtocol::_Response_default_instance_.debug_ = const_cast< ::SC2APIProtocol::ResponseDebug*>(
      ::SC2APIProtocol::ResponseDebug::internal_default_instance());
}
class Response::_Internal {
 public:
  using HasBits = decltype(std::declval<Response>()._has_bits_);
  static const ::SC2APIProtocol::ResponseCreateGame& create_game(const Response* msg);
  static const ::SC2APIProtocol::ResponseJoinGame& join_game(const Response* msg);
  static const ::SC2APIProtocol::ResponseRestartGame& restart_game(const Response* msg);
  static const ::SC2APIProtocol::ResponseStartReplay& start_replay(const Response* msg);
  static const ::SC2APIProtocol::ResponseLeaveGame& leave_game(const Response* msg);
  static const ::SC2APIProtocol::ResponseQuickSave& quick_save(const Response* msg);
  static const ::SC2APIProtocol::ResponseQuickLoad& quick_load(const Response* msg);
  static const ::SC2APIProtocol::ResponseQuit& quit(const Response* msg);
  static const ::SC2APIProtocol::ResponseGameInfo& game_info(const Response* msg);
  static const ::SC2APIProtocol::ResponseObservation& observation(const Response* msg);
  static const ::SC2APIProtocol::ResponseAction& action(const Response* msg);
  static const ::SC2APIProtocol::ResponseObserverAction& obs_action(const Response* msg);
  static const ::SC2APIProtocol::ResponseStep& step(const Response* msg);
  static const ::SC2APIProtocol::ResponseData& data(const Response* msg);
  static const ::SC2APIProtocol::ResponseQuery& query(const Response* msg);
  static const ::SC2APIProtocol::ResponseSaveReplay& save_replay(const Response* msg);
  static const ::SC2APIProtocol::ResponseReplayInfo& replay_info(const Response* msg);
  static const ::SC2APIProtocol::ResponseAvailableMaps& available_maps(const Response* msg);
  static const ::SC2APIProtocol::ResponseSaveMap& save_map(const Response* msg);
  static const ::SC2APIProtocol::ResponseMapCommand& map_command(const Response* msg);
  static const ::SC2APIProtocol::ResponsePing& ping(const Response* msg);
  static const ::SC2APIProtocol::ResponseDebug& debug(const Response* msg);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_status(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::ResponseCreateGame&
Response::_Internal::create_game(const Response* msg) {
  return *msg->response_.create_game_;
}
const ::SC2APIProtocol::ResponseJoinGame&
Response::_Internal::join_game(const Response* msg) {
  return *msg->response_.join_game_;
}
const ::SC2APIProtocol::ResponseRestartGame&
Response::_Internal::restart_game(const Response* msg) {
  return *msg->response_.restart_game_;
}
const ::SC2APIProtocol::ResponseStartReplay&
Response::_Internal::start_replay(const Response* msg) {
  return *msg->response_.start_replay_;
}
const ::SC2APIProtocol::ResponseLeaveGame&
Response::_Internal::leave_game(const Response* msg) {
  return *msg->response_.leave_game_;
}
const ::SC2APIProtocol::ResponseQuickSave&
Response::_Internal::quick_save(const Response* msg) {
  return *msg->response_.quick_save_;
}
const ::SC2APIProtocol::ResponseQuickLoad&
Response::_Internal::quick_load(const Response* msg) {
  return *msg->response_.quick_load_;
}
const ::SC2APIProtocol::ResponseQuit&
Response::_Internal::quit(const Response* msg) {
  return *msg->response_.quit_;
}
const ::SC2APIProtocol::ResponseGameInfo&
Response::_Internal::game_info(const Response* msg) {
  return *msg->response_.game_info_;
}
const ::SC2APIProtocol::ResponseObservation&
Response::_Internal::observation(const Response* msg) {
  return *msg->response_.observation_;
}
const ::SC2APIProtocol::ResponseAction&
Response::_Internal::action(const Response* msg) {
  return *msg->response_.action_;
}
const ::SC2APIProtocol::ResponseObserverAction&
Response::_Internal::obs_action(const Response* msg) {
  return *msg->response_.obs_action_;
}
const ::SC2APIProtocol::ResponseStep&
Response::_Internal::step(const Response* msg) {
  return *msg->response_.step_;
}
const ::SC2APIProtocol::ResponseData&
Response::_Internal::data(const Response* msg) {
  return *msg->response_.data_;
}
const ::SC2APIProtocol::ResponseQuery&
Response::_Internal::query(const Response* msg) {
  return *msg->response_.query_;
}
const ::SC2APIProtocol::ResponseSaveReplay&
Response::_Internal::save_replay(const Response* msg) {
  return *msg->response_.save_replay_;
}
const ::SC2APIProtocol::ResponseReplayInfo&
Response::_Internal::replay_info(const Response* msg) {
  return *msg->response_.replay_info_;
}
const ::SC2APIProtocol::ResponseAvailableMaps&
Response::_Internal::available_maps(const Response* msg) {
  return *msg->response_.available_maps_;
}
const ::SC2APIProtocol::ResponseSaveMap&
Response::_Internal::save_map(const Response* msg) {
  return *msg->response_.save_map_;
}
const ::SC2APIProtocol::ResponseMapCommand&
Response::_Internal::map_command(const Response* msg) {
  return *msg->response_.map_command_;
}
const ::SC2APIProtocol::ResponsePing&
Response::_Internal::ping(const Response* msg) {
  return *msg->response_.ping_;
}
const ::SC2APIProtocol::ResponseDebug&
Response::_Internal::debug(const Response* msg) {
  return *msg->response_.debug_;
}
void Response::set_allocated_create_game(::SC2APIProtocol::ResponseCreateGame* create_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (create_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      create_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_game, submessage_arena);
    }
    set_has_create_game();
    response_.create_game_ = create_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.create_game)
}
void Response::set_allocated_join_game(::SC2APIProtocol::ResponseJoinGame* join_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (join_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      join_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, join_game, submessage_arena);
    }
    set_has_join_game();
    response_.join_game_ = join_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.join_game)
}
void Response::set_allocated_restart_game(::SC2APIProtocol::ResponseRestartGame* restart_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (restart_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      restart_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, restart_game, submessage_arena);
    }
    set_has_restart_game();
    response_.restart_game_ = restart_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.restart_game)
}
void Response::set_allocated_start_replay(::SC2APIProtocol::ResponseStartReplay* start_replay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (start_replay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      start_replay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start_replay, submessage_arena);
    }
    set_has_start_replay();
    response_.start_replay_ = start_replay;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.start_replay)
}
void Response::set_allocated_leave_game(::SC2APIProtocol::ResponseLeaveGame* leave_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (leave_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      leave_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, leave_game, submessage_arena);
    }
    set_has_leave_game();
    response_.leave_game_ = leave_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.leave_game)
}
void Response::set_allocated_quick_save(::SC2APIProtocol::ResponseQuickSave* quick_save) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (quick_save) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      quick_save = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quick_save, submessage_arena);
    }
    set_has_quick_save();
    response_.quick_save_ = quick_save;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.quick_save)
}
void Response::set_allocated_quick_load(::SC2APIProtocol::ResponseQuickLoad* quick_load) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (quick_load) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      quick_load = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quick_load, submessage_arena);
    }
    set_has_quick_load();
    response_.quick_load_ = quick_load;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.quick_load)
}
void Response::set_allocated_quit(::SC2APIProtocol::ResponseQuit* quit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (quit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      quit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quit, submessage_arena);
    }
    set_has_quit();
    response_.quit_ = quit;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.quit)
}
void Response::set_allocated_game_info(::SC2APIProtocol::ResponseGameInfo* game_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (game_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      game_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, game_info, submessage_arena);
    }
    set_has_game_info();
    response_.game_info_ = game_info;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.game_info)
}
void Response::set_allocated_observation(::SC2APIProtocol::ResponseObservation* observation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (observation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      observation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, observation, submessage_arena);
    }
    set_has_observation();
    response_.observation_ = observation;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.observation)
}
void Response::set_allocated_action(::SC2APIProtocol::ResponseAction* action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, action, submessage_arena);
    }
    set_has_action();
    response_.action_ = action;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.action)
}
void Response::set_allocated_obs_action(::SC2APIProtocol::ResponseObserverAction* obs_action) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (obs_action) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      obs_action = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, obs_action, submessage_arena);
    }
    set_has_obs_action();
    response_.obs_action_ = obs_action;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.obs_action)
}
void Response::set_allocated_step(::SC2APIProtocol::ResponseStep* step) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (step) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      step = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, step, submessage_arena);
    }
    set_has_step();
    response_.step_ = step;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.step)
}
void Response::set_allocated_data(::SC2APIProtocol::ResponseData* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    response_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.data)
}
void Response::set_allocated_query(::SC2APIProtocol::ResponseQuery* query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, query, submessage_arena);
    }
    set_has_query();
    response_.query_ = query;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.query)
}
void Response::clear_query() {
  if (_internal_has_query()) {
    delete response_.query_;
    clear_has_response();
  }
}
void Response::set_allocated_save_replay(::SC2APIProtocol::ResponseSaveReplay* save_replay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (save_replay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      save_replay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, save_replay, submessage_arena);
    }
    set_has_save_replay();
    response_.save_replay_ = save_replay;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.save_replay)
}
void Response::set_allocated_replay_info(::SC2APIProtocol::ResponseReplayInfo* replay_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (replay_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      replay_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, replay_info, submessage_arena);
    }
    set_has_replay_info();
    response_.replay_info_ = replay_info;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.replay_info)
}
void Response::set_allocated_available_maps(::SC2APIProtocol::ResponseAvailableMaps* available_maps) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (available_maps) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      available_maps = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, available_maps, submessage_arena);
    }
    set_has_available_maps();
    response_.available_maps_ = available_maps;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.available_maps)
}
void Response::set_allocated_save_map(::SC2APIProtocol::ResponseSaveMap* save_map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (save_map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      save_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, save_map, submessage_arena);
    }
    set_has_save_map();
    response_.save_map_ = save_map;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.save_map)
}
void Response::set_allocated_map_command(::SC2APIProtocol::ResponseMapCommand* map_command) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (map_command) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      map_command = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, map_command, submessage_arena);
    }
    set_has_map_command();
    response_.map_command_ = map_command;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.map_command)
}
void Response::set_allocated_ping(::SC2APIProtocol::ResponsePing* ping) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (ping) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      ping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ping, submessage_arena);
    }
    set_has_ping();
    response_.ping_ = ping;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.ping)
}
void Response::set_allocated_debug(::SC2APIProtocol::ResponseDebug* debug) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_response();
  if (debug) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      debug = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, debug, submessage_arena);
    }
    set_has_debug();
    response_.debug_ = debug;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.Response.debug)
}
Response::Response()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.Response)
}
Response::Response(const Response& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      error_(from.error_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&status_) -
    reinterpret_cast<char*>(&id_)) + sizeof(status_));
  clear_has_response();
  switch (from.response_case()) {
    case kCreateGame: {
      _internal_mutable_create_game()->::SC2APIProtocol::ResponseCreateGame::MergeFrom(from._internal_create_game());
      break;
    }
    case kJoinGame: {
      _internal_mutable_join_game()->::SC2APIProtocol::ResponseJoinGame::MergeFrom(from._internal_join_game());
      break;
    }
    case kRestartGame: {
      _internal_mutable_restart_game()->::SC2APIProtocol::ResponseRestartGame::MergeFrom(from._internal_restart_game());
      break;
    }
    case kStartReplay: {
      _internal_mutable_start_replay()->::SC2APIProtocol::ResponseStartReplay::MergeFrom(from._internal_start_replay());
      break;
    }
    case kLeaveGame: {
      _internal_mutable_leave_game()->::SC2APIProtocol::ResponseLeaveGame::MergeFrom(from._internal_leave_game());
      break;
    }
    case kQuickSave: {
      _internal_mutable_quick_save()->::SC2APIProtocol::ResponseQuickSave::MergeFrom(from._internal_quick_save());
      break;
    }
    case kQuickLoad: {
      _internal_mutable_quick_load()->::SC2APIProtocol::ResponseQuickLoad::MergeFrom(from._internal_quick_load());
      break;
    }
    case kQuit: {
      _internal_mutable_quit()->::SC2APIProtocol::ResponseQuit::MergeFrom(from._internal_quit());
      break;
    }
    case kGameInfo: {
      _internal_mutable_game_info()->::SC2APIProtocol::ResponseGameInfo::MergeFrom(from._internal_game_info());
      break;
    }
    case kObservation: {
      _internal_mutable_observation()->::SC2APIProtocol::ResponseObservation::MergeFrom(from._internal_observation());
      break;
    }
    case kAction: {
      _internal_mutable_action()->::SC2APIProtocol::ResponseAction::MergeFrom(from._internal_action());
      break;
    }
    case kObsAction: {
      _internal_mutable_obs_action()->::SC2APIProtocol::ResponseObserverAction::MergeFrom(from._internal_obs_action());
      break;
    }
    case kStep: {
      _internal_mutable_step()->::SC2APIProtocol::ResponseStep::MergeFrom(from._internal_step());
      break;
    }
    case kData: {
      _internal_mutable_data()->::SC2APIProtocol::ResponseData::MergeFrom(from._internal_data());
      break;
    }
    case kQuery: {
      _internal_mutable_query()->::SC2APIProtocol::ResponseQuery::MergeFrom(from._internal_query());
      break;
    }
    case kSaveReplay: {
      _internal_mutable_save_replay()->::SC2APIProtocol::ResponseSaveReplay::MergeFrom(from._internal_save_replay());
      break;
    }
    case kReplayInfo: {
      _internal_mutable_replay_info()->::SC2APIProtocol::ResponseReplayInfo::MergeFrom(from._internal_replay_info());
      break;
    }
    case kAvailableMaps: {
      _internal_mutable_available_maps()->::SC2APIProtocol::ResponseAvailableMaps::MergeFrom(from._internal_available_maps());
      break;
    }
    case kSaveMap: {
      _internal_mutable_save_map()->::SC2APIProtocol::ResponseSaveMap::MergeFrom(from._internal_save_map());
      break;
    }
    case kMapCommand: {
      _internal_mutable_map_command()->::SC2APIProtocol::ResponseMapCommand::MergeFrom(from._internal_map_command());
      break;
    }
    case kPing: {
      _internal_mutable_ping()->::SC2APIProtocol::ResponsePing::MergeFrom(from._internal_ping());
      break;
    }
    case kDebug: {
      _internal_mutable_debug()->::SC2APIProtocol::ResponseDebug::MergeFrom(from._internal_debug());
      break;
    }
    case RESPONSE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.Response)
}

void Response::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Response_s2clientprotocol_2fsc2api_2eproto.base);
  id_ = 0u;
  status_ = 1;
  clear_has_response();
}

Response::~Response() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.Response)
  SharedDtor();
}

void Response::SharedDtor() {
  if (has_response()) {
    clear_response();
  }
}

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


void Response::clear_response() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.Response)
  switch (response_case()) {
    case kCreateGame: {
      delete response_.create_game_;
      break;
    }
    case kJoinGame: {
      delete response_.join_game_;
      break;
    }
    case kRestartGame: {
      delete response_.restart_game_;
      break;
    }
    case kStartReplay: {
      delete response_.start_replay_;
      break;
    }
    case kLeaveGame: {
      delete response_.leave_game_;
      break;
    }
    case kQuickSave: {
      delete response_.quick_save_;
      break;
    }
    case kQuickLoad: {
      delete response_.quick_load_;
      break;
    }
    case kQuit: {
      delete response_.quit_;
      break;
    }
    case kGameInfo: {
      delete response_.game_info_;
      break;
    }
    case kObservation: {
      delete response_.observation_;
      break;
    }
    case kAction: {
      delete response_.action_;
      break;
    }
    case kObsAction: {
      delete response_.obs_action_;
      break;
    }
    case kStep: {
      delete response_.step_;
      break;
    }
    case kData: {
      delete response_.data_;
      break;
    }
    case kQuery: {
      delete response_.query_;
      break;
    }
    case kSaveReplay: {
      delete response_.save_replay_;
      break;
    }
    case kReplayInfo: {
      delete response_.replay_info_;
      break;
    }
    case kAvailableMaps: {
      delete response_.available_maps_;
      break;
    }
    case kSaveMap: {
      delete response_.save_map_;
      break;
    }
    case kMapCommand: {
      delete response_.map_command_;
      break;
    }
    case kPing: {
      delete response_.ping_;
      break;
    }
    case kDebug: {
      delete response_.debug_;
      break;
    }
    case RESPONSE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = RESPONSE_NOT_SET;
}


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

  error_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    id_ = 0u;
    status_ = 1;
  }
  clear_response();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Response::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ResponseCreateGame create_game = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_create_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseJoinGame join_game = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_join_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseRestartGame restart_game = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_restart_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseStartReplay start_replay = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_start_replay(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseLeaveGame leave_game = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_leave_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseQuickSave quick_save = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_quick_save(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseQuickLoad quick_load = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_quick_load(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseQuit quit = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_quit(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseGameInfo game_info = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_game_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseObservation observation = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_observation(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseAction action = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_action(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseStep step = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_step(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseData data = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseQuery query = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_query(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseSaveReplay save_replay = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_save_replay(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseReplayInfo replay_info = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_replay_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseAvailableMaps available_maps = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_available_maps(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseSaveMap save_map = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_save_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponsePing ping = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_ping(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseDebug debug = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_debug(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseObserverAction obs_action = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_obs_action(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseMapCommand map_command = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_map_command(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 id = 97;
      case 97:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string error = 98;
      case 98:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 2;
          do {
            ptr += 2;
            auto str = _internal_add_error();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.Response.error");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<786>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Status status = 99;
      case 99:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Status_IsValid(val))) {
            _internal_set_status(static_cast<::SC2APIProtocol::Status>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(99, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  switch (response_case()) {
    case kCreateGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::create_game(this), target, stream);
      break;
    }
    case kJoinGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::join_game(this), target, stream);
      break;
    }
    case kRestartGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::restart_game(this), target, stream);
      break;
    }
    case kStartReplay: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::start_replay(this), target, stream);
      break;
    }
    case kLeaveGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::leave_game(this), target, stream);
      break;
    }
    case kQuickSave: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::quick_save(this), target, stream);
      break;
    }
    case kQuickLoad: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::quick_load(this), target, stream);
      break;
    }
    case kQuit: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          8, _Internal::quit(this), target, stream);
      break;
    }
    case kGameInfo: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          9, _Internal::game_info(this), target, stream);
      break;
    }
    case kObservation: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          10, _Internal::observation(this), target, stream);
      break;
    }
    case kAction: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          11, _Internal::action(this), target, stream);
      break;
    }
    case kStep: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          12, _Internal::step(this), target, stream);
      break;
    }
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          13, _Internal::data(this), target, stream);
      break;
    }
    case kQuery: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          14, _Internal::query(this), target, stream);
      break;
    }
    case kSaveReplay: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          15, _Internal::save_replay(this), target, stream);
      break;
    }
    case kReplayInfo: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          16, _Internal::replay_info(this), target, stream);
      break;
    }
    case kAvailableMaps: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          17, _Internal::available_maps(this), target, stream);
      break;
    }
    case kSaveMap: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          18, _Internal::save_map(this), target, stream);
      break;
    }
    case kPing: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          19, _Internal::ping(this), target, stream);
      break;
    }
    case kDebug: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          20, _Internal::debug(this), target, stream);
      break;
    }
    case kObsAction: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          21, _Internal::obs_action(this), target, stream);
      break;
    }
    case kMapCommand: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          22, _Internal::map_command(this), target, stream);
      break;
    }
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional uint32 id = 97;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(97, this->_internal_id(), target);
  }

  // repeated string error = 98;
  for (int i = 0, n = this->_internal_error_size(); i < n; i++) {
    const auto& s = this->_internal_error(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.Response.error");
    target = stream->WriteString(98, s, target);
  }

  // optional .SC2APIProtocol.Status status = 99;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      99, this->_internal_status(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.Response)
  return target;
}

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

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

  // repeated string error = 98;
  total_size += 2 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(error_.size());
  for (int i = 0, n = error_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      error_.Get(i));
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional uint32 id = 97;
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_id());
    }

    // optional .SC2APIProtocol.Status status = 99;
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status());
    }

  }
  switch (response_case()) {
    // optional .SC2APIProtocol.ResponseCreateGame create_game = 1;
    case kCreateGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.create_game_);
      break;
    }
    // optional .SC2APIProtocol.ResponseJoinGame join_game = 2;
    case kJoinGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.join_game_);
      break;
    }
    // optional .SC2APIProtocol.ResponseRestartGame restart_game = 3;
    case kRestartGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.restart_game_);
      break;
    }
    // optional .SC2APIProtocol.ResponseStartReplay start_replay = 4;
    case kStartReplay: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.start_replay_);
      break;
    }
    // optional .SC2APIProtocol.ResponseLeaveGame leave_game = 5;
    case kLeaveGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.leave_game_);
      break;
    }
    // optional .SC2APIProtocol.ResponseQuickSave quick_save = 6;
    case kQuickSave: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.quick_save_);
      break;
    }
    // optional .SC2APIProtocol.ResponseQuickLoad quick_load = 7;
    case kQuickLoad: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.quick_load_);
      break;
    }
    // optional .SC2APIProtocol.ResponseQuit quit = 8;
    case kQuit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.quit_);
      break;
    }
    // optional .SC2APIProtocol.ResponseGameInfo game_info = 9;
    case kGameInfo: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.game_info_);
      break;
    }
    // optional .SC2APIProtocol.ResponseObservation observation = 10;
    case kObservation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.observation_);
      break;
    }
    // optional .SC2APIProtocol.ResponseAction action = 11;
    case kAction: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.action_);
      break;
    }
    // optional .SC2APIProtocol.ResponseObserverAction obs_action = 21;
    case kObsAction: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.obs_action_);
      break;
    }
    // optional .SC2APIProtocol.ResponseStep step = 12;
    case kStep: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.step_);
      break;
    }
    // optional .SC2APIProtocol.ResponseData data = 13;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.data_);
      break;
    }
    // optional .SC2APIProtocol.ResponseQuery query = 14;
    case kQuery: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.query_);
      break;
    }
    // optional .SC2APIProtocol.ResponseSaveReplay save_replay = 15;
    case kSaveReplay: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.save_replay_);
      break;
    }
    // optional .SC2APIProtocol.ResponseReplayInfo replay_info = 16;
    case kReplayInfo: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.replay_info_);
      break;
    }
    // optional .SC2APIProtocol.ResponseAvailableMaps available_maps = 17;
    case kAvailableMaps: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.available_maps_);
      break;
    }
    // optional .SC2APIProtocol.ResponseSaveMap save_map = 18;
    case kSaveMap: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.save_map_);
      break;
    }
    // optional .SC2APIProtocol.ResponseMapCommand map_command = 22;
    case kMapCommand: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.map_command_);
      break;
    }
    // optional .SC2APIProtocol.ResponsePing ping = 19;
    case kPing: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.ping_);
      break;
    }
    // optional .SC2APIProtocol.ResponseDebug debug = 20;
    case kDebug: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *response_.debug_);
      break;
    }
    case RESPONSE_NOT_SET: {
      break;
    }
  }
  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 Response::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.Response)
  GOOGLE_DCHECK_NE(&from, this);
  const Response* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Response>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.Response)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.Response)
    MergeFrom(*source);
  }
}

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

  error_.MergeFrom(from.error_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000002u) {
      status_ = from.status_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.response_case()) {
    case kCreateGame: {
      _internal_mutable_create_game()->::SC2APIProtocol::ResponseCreateGame::MergeFrom(from._internal_create_game());
      break;
    }
    case kJoinGame: {
      _internal_mutable_join_game()->::SC2APIProtocol::ResponseJoinGame::MergeFrom(from._internal_join_game());
      break;
    }
    case kRestartGame: {
      _internal_mutable_restart_game()->::SC2APIProtocol::ResponseRestartGame::MergeFrom(from._internal_restart_game());
      break;
    }
    case kStartReplay: {
      _internal_mutable_start_replay()->::SC2APIProtocol::ResponseStartReplay::MergeFrom(from._internal_start_replay());
      break;
    }
    case kLeaveGame: {
      _internal_mutable_leave_game()->::SC2APIProtocol::ResponseLeaveGame::MergeFrom(from._internal_leave_game());
      break;
    }
    case kQuickSave: {
      _internal_mutable_quick_save()->::SC2APIProtocol::ResponseQuickSave::MergeFrom(from._internal_quick_save());
      break;
    }
    case kQuickLoad: {
      _internal_mutable_quick_load()->::SC2APIProtocol::ResponseQuickLoad::MergeFrom(from._internal_quick_load());
      break;
    }
    case kQuit: {
      _internal_mutable_quit()->::SC2APIProtocol::ResponseQuit::MergeFrom(from._internal_quit());
      break;
    }
    case kGameInfo: {
      _internal_mutable_game_info()->::SC2APIProtocol::ResponseGameInfo::MergeFrom(from._internal_game_info());
      break;
    }
    case kObservation: {
      _internal_mutable_observation()->::SC2APIProtocol::ResponseObservation::MergeFrom(from._internal_observation());
      break;
    }
    case kAction: {
      _internal_mutable_action()->::SC2APIProtocol::ResponseAction::MergeFrom(from._internal_action());
      break;
    }
    case kObsAction: {
      _internal_mutable_obs_action()->::SC2APIProtocol::ResponseObserverAction::MergeFrom(from._internal_obs_action());
      break;
    }
    case kStep: {
      _internal_mutable_step()->::SC2APIProtocol::ResponseStep::MergeFrom(from._internal_step());
      break;
    }
    case kData: {
      _internal_mutable_data()->::SC2APIProtocol::ResponseData::MergeFrom(from._internal_data());
      break;
    }
    case kQuery: {
      _internal_mutable_query()->::SC2APIProtocol::ResponseQuery::MergeFrom(from._internal_query());
      break;
    }
    case kSaveReplay: {
      _internal_mutable_save_replay()->::SC2APIProtocol::ResponseSaveReplay::MergeFrom(from._internal_save_replay());
      break;
    }
    case kReplayInfo: {
      _internal_mutable_replay_info()->::SC2APIProtocol::ResponseReplayInfo::MergeFrom(from._internal_replay_info());
      break;
    }
    case kAvailableMaps: {
      _internal_mutable_available_maps()->::SC2APIProtocol::ResponseAvailableMaps::MergeFrom(from._internal_available_maps());
      break;
    }
    case kSaveMap: {
      _internal_mutable_save_map()->::SC2APIProtocol::ResponseSaveMap::MergeFrom(from._internal_save_map());
      break;
    }
    case kMapCommand: {
      _internal_mutable_map_command()->::SC2APIProtocol::ResponseMapCommand::MergeFrom(from._internal_map_command());
      break;
    }
    case kPing: {
      _internal_mutable_ping()->::SC2APIProtocol::ResponsePing::MergeFrom(from._internal_ping());
      break;
    }
    case kDebug: {
      _internal_mutable_debug()->::SC2APIProtocol::ResponseDebug::MergeFrom(from._internal_debug());
      break;
    }
    case RESPONSE_NOT_SET: {
      break;
    }
  }
}

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

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

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

void Response::InternalSwap(Response* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_.InternalSwap(&other->error_);
  swap(id_, other->id_);
  swap(status_, other->status_);
  swap(response_, other->response_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void RequestCreateGame::InitAsDefaultInstance() {
  ::SC2APIProtocol::_RequestCreateGame_default_instance_.local_map_ = const_cast< ::SC2APIProtocol::LocalMap*>(
      ::SC2APIProtocol::LocalMap::internal_default_instance());
  ::SC2APIProtocol::_RequestCreateGame_default_instance_.battlenet_map_name_.UnsafeSetDefault(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
class RequestCreateGame::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestCreateGame>()._has_bits_);
  static const ::SC2APIProtocol::LocalMap& local_map(const RequestCreateGame* msg);
  static void set_has_disable_fog(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_random_seed(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_realtime(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

const ::SC2APIProtocol::LocalMap&
RequestCreateGame::_Internal::local_map(const RequestCreateGame* msg) {
  return *msg->Map_.local_map_;
}
void RequestCreateGame::set_allocated_local_map(::SC2APIProtocol::LocalMap* local_map) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_Map();
  if (local_map) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      local_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_map, submessage_arena);
    }
    set_has_local_map();
    Map_.local_map_ = local_map;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.RequestCreateGame.local_map)
}
RequestCreateGame::RequestCreateGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestCreateGame)
}
RequestCreateGame::RequestCreateGame(const RequestCreateGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      player_setup_(from.player_setup_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&random_seed_, &from.random_seed_,
    static_cast<size_t>(reinterpret_cast<char*>(&realtime_) -
    reinterpret_cast<char*>(&random_seed_)) + sizeof(realtime_));
  clear_has_Map();
  switch (from.Map_case()) {
    case kLocalMap: {
      _internal_mutable_local_map()->::SC2APIProtocol::LocalMap::MergeFrom(from._internal_local_map());
      break;
    }
    case kBattlenetMapName: {
      _internal_set_battlenet_map_name(from._internal_battlenet_map_name());
      break;
    }
    case MAP_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestCreateGame)
}

void RequestCreateGame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestCreateGame_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&random_seed_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&realtime_) -
      reinterpret_cast<char*>(&random_seed_)) + sizeof(realtime_));
  clear_has_Map();
}

RequestCreateGame::~RequestCreateGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestCreateGame)
  SharedDtor();
}

void RequestCreateGame::SharedDtor() {
  if (has_Map()) {
    clear_Map();
  }
}

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


void RequestCreateGame::clear_Map() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.RequestCreateGame)
  switch (Map_case()) {
    case kLocalMap: {
      delete Map_.local_map_;
      break;
    }
    case kBattlenetMapName: {
      Map_.battlenet_map_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case MAP_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = MAP_NOT_SET;
}


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

  player_setup_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&random_seed_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&realtime_) -
        reinterpret_cast<char*>(&random_seed_)) + sizeof(realtime_));
  }
  clear_Map();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestCreateGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.LocalMap local_map = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_local_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string battlenet_map_name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_battlenet_map_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestCreateGame.battlenet_map_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.PlayerSetup player_setup = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_player_setup(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bool disable_fog = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_disable_fog(&has_bits);
          disable_fog_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 random_seed = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_random_seed(&has_bits);
          random_seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool realtime = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_realtime(&has_bits);
          realtime_ = ::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_, 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* RequestCreateGame::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.RequestCreateGame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (Map_case()) {
    case kLocalMap: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::local_map(this), target, stream);
      break;
    }
    case kBattlenetMapName: {
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
        this->_internal_battlenet_map_name().data(), static_cast<int>(this->_internal_battlenet_map_name().length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
        "SC2APIProtocol.RequestCreateGame.battlenet_map_name");
      target = stream->WriteStringMaybeAliased(
          2, this->_internal_battlenet_map_name(), target);
      break;
    }
    default: ;
  }
  // repeated .SC2APIProtocol.PlayerSetup player_setup = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_player_setup_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_player_setup(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional bool disable_fog = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_disable_fog(), target);
  }

  // optional uint32 random_seed = 5;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_random_seed(), target);
  }

  // optional bool realtime = 6;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_realtime(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestCreateGame)
  return target;
}

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

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

  // repeated .SC2APIProtocol.PlayerSetup player_setup = 3;
  total_size += 1UL * this->_internal_player_setup_size();
  for (const auto& msg : this->player_setup_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional uint32 random_seed = 5;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_random_seed());
    }

    // optional bool disable_fog = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional bool realtime = 6;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

  }
  switch (Map_case()) {
    // optional .SC2APIProtocol.LocalMap local_map = 1;
    case kLocalMap: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *Map_.local_map_);
      break;
    }
    // optional string battlenet_map_name = 2;
    case kBattlenetMapName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_battlenet_map_name());
      break;
    }
    case MAP_NOT_SET: {
      break;
    }
  }
  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 RequestCreateGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestCreateGame)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestCreateGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestCreateGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestCreateGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestCreateGame)
    MergeFrom(*source);
  }
}

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

  player_setup_.MergeFrom(from.player_setup_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      random_seed_ = from.random_seed_;
    }
    if (cached_has_bits & 0x00000002u) {
      disable_fog_ = from.disable_fog_;
    }
    if (cached_has_bits & 0x00000004u) {
      realtime_ = from.realtime_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.Map_case()) {
    case kLocalMap: {
      _internal_mutable_local_map()->::SC2APIProtocol::LocalMap::MergeFrom(from._internal_local_map());
      break;
    }
    case kBattlenetMapName: {
      _internal_set_battlenet_map_name(from._internal_battlenet_map_name());
      break;
    }
    case MAP_NOT_SET: {
      break;
    }
  }
}

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

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

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

void RequestCreateGame::InternalSwap(RequestCreateGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  player_setup_.InternalSwap(&other->player_setup_);
  swap(random_seed_, other->random_seed_);
  swap(disable_fog_, other->disable_fog_);
  swap(realtime_, other->realtime_);
  swap(Map_, other->Map_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void LocalMap::InitAsDefaultInstance() {
}
class LocalMap::_Internal {
 public:
  using HasBits = decltype(std::declval<LocalMap>()._has_bits_);
  static void set_has_map_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_map_data(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

LocalMap::LocalMap()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.LocalMap)
}
LocalMap::LocalMap(const LocalMap& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_path()) {
    map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_path_);
  }
  map_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_data()) {
    map_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_data_);
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.LocalMap)
}

void LocalMap::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LocalMap_s2clientprotocol_2fsc2api_2eproto.base);
  map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  map_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

LocalMap::~LocalMap() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.LocalMap)
  SharedDtor();
}

void LocalMap::SharedDtor() {
  map_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  map_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void LocalMap::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.LocalMap)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      map_path_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      map_data_.ClearNonDefaultToEmptyNoArena();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* LocalMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string map_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_map_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.LocalMap.map_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes map_data = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_map_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional string map_path = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_map_path().data(), static_cast<int>(this->_internal_map_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.LocalMap.map_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_map_path(), target);
  }

  // optional bytes map_data = 7;
  if (cached_has_bits & 0x00000002u) {
    target = stream->WriteBytesMaybeAliased(
        7, this->_internal_map_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.LocalMap)
  return target;
}

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

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

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

    // optional bytes map_data = 7;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_map_data());
    }

  }
  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 LocalMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.LocalMap)
  GOOGLE_DCHECK_NE(&from, this);
  const LocalMap* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LocalMap>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.LocalMap)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.LocalMap)
    MergeFrom(*source);
  }
}

void LocalMap::MergeFrom(const LocalMap& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.LocalMap)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_path_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      map_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_data_);
    }
  }
}

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

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

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

void LocalMap::InternalSwap(LocalMap* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  map_path_.Swap(&other->map_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  map_data_.Swap(&other->map_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

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


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

void ResponseCreateGame::InitAsDefaultInstance() {
}
class ResponseCreateGame::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseCreateGame>()._has_bits_);
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_error_details(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseCreateGame::ResponseCreateGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseCreateGame)
}
ResponseCreateGame::ResponseCreateGame(const ResponseCreateGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_details()) {
    error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
  }
  error_ = from.error_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseCreateGame)
}

void ResponseCreateGame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseCreateGame_s2clientprotocol_2fsc2api_2eproto.base);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_ = 1;
}

ResponseCreateGame::~ResponseCreateGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseCreateGame)
  SharedDtor();
}

void ResponseCreateGame::SharedDtor() {
  error_details_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponseCreateGame::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponseCreateGame)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      error_details_.ClearNonDefaultToEmptyNoArena();
    }
    error_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseCreateGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ResponseCreateGame.Error error = 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(::SC2APIProtocol::ResponseCreateGame_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseCreateGame_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string error_details = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_error_details();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseCreateGame.error_details");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ResponseCreateGame.Error error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_error(), target);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseCreateGame)
  return target;
}

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

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

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

    // optional .SC2APIProtocol.ResponseCreateGame.Error error = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  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 ResponseCreateGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseCreateGame)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseCreateGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseCreateGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseCreateGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseCreateGame)
    MergeFrom(*source);
  }
}

void ResponseCreateGame::MergeFrom(const ResponseCreateGame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ResponseCreateGame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
    }
    if (cached_has_bits & 0x00000002u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponseCreateGame::InternalSwap(ResponseCreateGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_details_.Swap(&other->error_details_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(error_, other->error_);
}

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


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

void RequestJoinGame::InitAsDefaultInstance() {
  ::SC2APIProtocol::_RequestJoinGame_default_instance_.race_ = 0;
  ::SC2APIProtocol::_RequestJoinGame_default_instance_.observed_player_id_ = 0u;
  ::SC2APIProtocol::_RequestJoinGame_default_instance_._instance.get_mutable()->options_ = const_cast< ::SC2APIProtocol::InterfaceOptions*>(
      ::SC2APIProtocol::InterfaceOptions::internal_default_instance());
  ::SC2APIProtocol::_RequestJoinGame_default_instance_._instance.get_mutable()->server_ports_ = const_cast< ::SC2APIProtocol::PortSet*>(
      ::SC2APIProtocol::PortSet::internal_default_instance());
}
class RequestJoinGame::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestJoinGame>()._has_bits_);
  static const ::SC2APIProtocol::InterfaceOptions& options(const RequestJoinGame* msg);
  static void set_has_options(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::PortSet& server_ports(const RequestJoinGame* msg);
  static void set_has_server_ports(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_shared_port(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_player_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_host_ip(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::InterfaceOptions&
RequestJoinGame::_Internal::options(const RequestJoinGame* msg) {
  return *msg->options_;
}
const ::SC2APIProtocol::PortSet&
RequestJoinGame::_Internal::server_ports(const RequestJoinGame* msg) {
  return *msg->server_ports_;
}
RequestJoinGame::RequestJoinGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestJoinGame)
}
RequestJoinGame::RequestJoinGame(const RequestJoinGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      client_ports_(from.client_ports_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  player_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_player_name()) {
    player_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.player_name_);
  }
  host_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_host_ip()) {
    host_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.host_ip_);
  }
  if (from._internal_has_options()) {
    options_ = new ::SC2APIProtocol::InterfaceOptions(*from.options_);
  } else {
    options_ = nullptr;
  }
  if (from._internal_has_server_ports()) {
    server_ports_ = new ::SC2APIProtocol::PortSet(*from.server_ports_);
  } else {
    server_ports_ = nullptr;
  }
  shared_port_ = from.shared_port_;
  clear_has_participation();
  switch (from.participation_case()) {
    case kRace: {
      _internal_set_race(from._internal_race());
      break;
    }
    case kObservedPlayerId: {
      _internal_set_observed_player_id(from._internal_observed_player_id());
      break;
    }
    case PARTICIPATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestJoinGame)
}

void RequestJoinGame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestJoinGame_s2clientprotocol_2fsc2api_2eproto.base);
  player_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  host_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&options_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&shared_port_) -
      reinterpret_cast<char*>(&options_)) + sizeof(shared_port_));
  clear_has_participation();
}

RequestJoinGame::~RequestJoinGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestJoinGame)
  SharedDtor();
}

void RequestJoinGame::SharedDtor() {
  player_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  host_ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete options_;
  if (this != internal_default_instance()) delete server_ports_;
  if (has_participation()) {
    clear_participation();
  }
}

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


void RequestJoinGame::clear_participation() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.RequestJoinGame)
  switch (participation_case()) {
    case kRace: {
      // No need to clear
      break;
    }
    case kObservedPlayerId: {
      // No need to clear
      break;
    }
    case PARTICIPATION_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = PARTICIPATION_NOT_SET;
}


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

  client_ports_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      player_name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      host_ip_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(options_ != nullptr);
      options_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(server_ports_ != nullptr);
      server_ports_->Clear();
    }
  }
  shared_port_ = 0;
  clear_participation();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestJoinGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.Race race = 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(::SC2APIProtocol::Race_IsValid(val))) {
            _internal_set_race(static_cast<::SC2APIProtocol::Race>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 observed_player_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _internal_set_observed_player_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.InterfaceOptions options = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.PortSet server_ports = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_server_ports(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.PortSet client_ports = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_client_ports(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int32 shared_port = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_shared_port(&has_bits);
          shared_port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string player_name = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_player_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestJoinGame.player_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string host_ip = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          auto str = _internal_mutable_host_ip();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestJoinGame.host_ip");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  switch (participation_case()) {
    case kRace: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        1, this->_internal_race(), target);
      break;
    }
    case kObservedPlayerId: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_observed_player_id(), target);
      break;
    }
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.InterfaceOptions options = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::options(this), target, stream);
  }

  // optional .SC2APIProtocol.PortSet server_ports = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::server_ports(this), target, stream);
  }

  // repeated .SC2APIProtocol.PortSet client_ports = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_client_ports_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_client_ports(i), target, stream);
  }

  // optional int32 shared_port = 6;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_shared_port(), target);
  }

  // optional string player_name = 7;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_player_name().data(), static_cast<int>(this->_internal_player_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.RequestJoinGame.player_name");
    target = stream->WriteStringMaybeAliased(
        7, this->_internal_player_name(), target);
  }

  // optional string host_ip = 8;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_host_ip().data(), static_cast<int>(this->_internal_host_ip().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.RequestJoinGame.host_ip");
    target = stream->WriteStringMaybeAliased(
        8, this->_internal_host_ip(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestJoinGame)
  return target;
}

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

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

  // repeated .SC2APIProtocol.PortSet client_ports = 5;
  total_size += 1UL * this->_internal_client_ports_size();
  for (const auto& msg : this->client_ports_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string player_name = 7;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_player_name());
    }

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

    // optional .SC2APIProtocol.InterfaceOptions options = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *options_);
    }

    // optional .SC2APIProtocol.PortSet server_ports = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *server_ports_);
    }

    // optional int32 shared_port = 6;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_shared_port());
    }

  }
  switch (participation_case()) {
    // optional .SC2APIProtocol.Race race = 1;
    case kRace: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_race());
      break;
    }
    // optional uint32 observed_player_id = 2;
    case kObservedPlayerId: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_observed_player_id());
      break;
    }
    case PARTICIPATION_NOT_SET: {
      break;
    }
  }
  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 RequestJoinGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestJoinGame)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestJoinGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestJoinGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestJoinGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestJoinGame)
    MergeFrom(*source);
  }
}

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

  client_ports_.MergeFrom(from.client_ports_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      player_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.player_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      host_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.host_ip_);
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_options()->::SC2APIProtocol::InterfaceOptions::MergeFrom(from._internal_options());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_server_ports()->::SC2APIProtocol::PortSet::MergeFrom(from._internal_server_ports());
    }
    if (cached_has_bits & 0x00000010u) {
      shared_port_ = from.shared_port_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.participation_case()) {
    case kRace: {
      _internal_set_race(from._internal_race());
      break;
    }
    case kObservedPlayerId: {
      _internal_set_observed_player_id(from._internal_observed_player_id());
      break;
    }
    case PARTICIPATION_NOT_SET: {
      break;
    }
  }
}

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

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

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

void RequestJoinGame::InternalSwap(RequestJoinGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  client_ports_.InternalSwap(&other->client_ports_);
  player_name_.Swap(&other->player_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  host_ip_.Swap(&other->host_ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(options_, other->options_);
  swap(server_ports_, other->server_ports_);
  swap(shared_port_, other->shared_port_);
  swap(participation_, other->participation_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void PortSet::InitAsDefaultInstance() {
}
class PortSet::_Internal {
 public:
  using HasBits = decltype(std::declval<PortSet>()._has_bits_);
  static void set_has_game_port(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_base_port(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

PortSet::PortSet()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.PortSet)
}
PortSet::PortSet(const PortSet& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&game_port_, &from.game_port_,
    static_cast<size_t>(reinterpret_cast<char*>(&base_port_) -
    reinterpret_cast<char*>(&game_port_)) + sizeof(base_port_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.PortSet)
}

void PortSet::SharedCtor() {
  ::memset(&game_port_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&base_port_) -
      reinterpret_cast<char*>(&game_port_)) + sizeof(base_port_));
}

PortSet::~PortSet() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.PortSet)
  SharedDtor();
}

void PortSet::SharedDtor() {
}

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


void PortSet::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.PortSet)
  ::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 & 0x00000003u) {
    ::memset(&game_port_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&base_port_) -
        reinterpret_cast<char*>(&game_port_)) + sizeof(base_port_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* PortSet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 game_port = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_game_port(&has_bits);
          game_port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 base_port = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_base_port(&has_bits);
          base_port_ = ::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_, 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* PortSet::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.PortSet)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 game_port = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_game_port(), target);
  }

  // optional int32 base_port = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_base_port(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.PortSet)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int32 game_port = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_game_port());
    }

    // optional int32 base_port = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_base_port());
    }

  }
  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 PortSet::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.PortSet)
  GOOGLE_DCHECK_NE(&from, this);
  const PortSet* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PortSet>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.PortSet)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.PortSet)
    MergeFrom(*source);
  }
}

void PortSet::MergeFrom(const PortSet& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.PortSet)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      game_port_ = from.game_port_;
    }
    if (cached_has_bits & 0x00000002u) {
      base_port_ = from.base_port_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void PortSet::InternalSwap(PortSet* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(game_port_, other->game_port_);
  swap(base_port_, other->base_port_);
}

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


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

void ResponseJoinGame::InitAsDefaultInstance() {
}
class ResponseJoinGame::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseJoinGame>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_error_details(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseJoinGame::ResponseJoinGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseJoinGame)
}
ResponseJoinGame::ResponseJoinGame(const ResponseJoinGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_details()) {
    error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
  }
  ::memcpy(&player_id_, &from.player_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&error_) -
    reinterpret_cast<char*>(&player_id_)) + sizeof(error_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseJoinGame)
}

void ResponseJoinGame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseJoinGame_s2clientprotocol_2fsc2api_2eproto.base);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  player_id_ = 0u;
  error_ = 1;
}

ResponseJoinGame::~ResponseJoinGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseJoinGame)
  SharedDtor();
}

void ResponseJoinGame::SharedDtor() {
  error_details_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponseJoinGame::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponseJoinGame)
  ::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 & 0x00000001u) {
    error_details_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    player_id_ = 0u;
    error_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseJoinGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseJoinGame.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::ResponseJoinGame_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseJoinGame_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string error_details = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_error_details();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseJoinGame.error_details");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

  // optional .SC2APIProtocol.ResponseJoinGame.Error error = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_error(), target);
  }

  // optional string error_details = 3;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_error_details().data(), static_cast<int>(this->_internal_error_details().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseJoinGame.error_details");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_error_details(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseJoinGame)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string error_details = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_error_details());
    }

    // optional uint32 player_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_player_id());
    }

    // optional .SC2APIProtocol.ResponseJoinGame.Error error = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  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 ResponseJoinGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseJoinGame)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseJoinGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseJoinGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseJoinGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseJoinGame)
    MergeFrom(*source);
  }
}

void ResponseJoinGame::MergeFrom(const ResponseJoinGame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ResponseJoinGame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
    }
    if (cached_has_bits & 0x00000002u) {
      player_id_ = from.player_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponseJoinGame::InternalSwap(ResponseJoinGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_details_.Swap(&other->error_details_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(player_id_, other->player_id_);
  swap(error_, other->error_);
}

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


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

void RequestRestartGame::InitAsDefaultInstance() {
}
class RequestRestartGame::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestRestartGame>()._has_bits_);
};

RequestRestartGame::RequestRestartGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestRestartGame)
}
RequestRestartGame::RequestRestartGame(const RequestRestartGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestRestartGame)
}

void RequestRestartGame::SharedCtor() {
}

RequestRestartGame::~RequestRestartGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestRestartGame)
  SharedDtor();
}

void RequestRestartGame::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestRestartGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestRestartGame)
  return target;
}

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

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

  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 RequestRestartGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestRestartGame)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestRestartGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestRestartGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestRestartGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestRestartGame)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestRestartGame::InternalSwap(RequestRestartGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseRestartGame::InitAsDefaultInstance() {
}
class ResponseRestartGame::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseRestartGame>()._has_bits_);
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_error_details(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_need_hard_reset(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

ResponseRestartGame::ResponseRestartGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseRestartGame)
}
ResponseRestartGame::ResponseRestartGame(const ResponseRestartGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_details()) {
    error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
  }
  ::memcpy(&need_hard_reset_, &from.need_hard_reset_,
    static_cast<size_t>(reinterpret_cast<char*>(&error_) -
    reinterpret_cast<char*>(&need_hard_reset_)) + sizeof(error_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseRestartGame)
}

void ResponseRestartGame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseRestartGame_s2clientprotocol_2fsc2api_2eproto.base);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  need_hard_reset_ = false;
  error_ = 1;
}

ResponseRestartGame::~ResponseRestartGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseRestartGame)
  SharedDtor();
}

void ResponseRestartGame::SharedDtor() {
  error_details_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponseRestartGame::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponseRestartGame)
  ::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 & 0x00000001u) {
    error_details_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    need_hard_reset_ = false;
    error_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseRestartGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ResponseRestartGame.Error error = 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(::SC2APIProtocol::ResponseRestartGame_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseRestartGame_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string error_details = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_error_details();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseRestartGame.error_details");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool need_hard_reset = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_need_hard_reset(&has_bits);
          need_hard_reset_ = ::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_, 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* ResponseRestartGame::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ResponseRestartGame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ResponseRestartGame.Error error = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_error(), target);
  }

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

  // optional bool need_hard_reset = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_need_hard_reset(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseRestartGame)
  return target;
}

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

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

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

    // optional bool need_hard_reset = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional .SC2APIProtocol.ResponseRestartGame.Error error = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  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 ResponseRestartGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseRestartGame)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseRestartGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseRestartGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseRestartGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseRestartGame)
    MergeFrom(*source);
  }
}

void ResponseRestartGame::MergeFrom(const ResponseRestartGame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ResponseRestartGame)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
    }
    if (cached_has_bits & 0x00000002u) {
      need_hard_reset_ = from.need_hard_reset_;
    }
    if (cached_has_bits & 0x00000004u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponseRestartGame::InternalSwap(ResponseRestartGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_details_.Swap(&other->error_details_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(need_hard_reset_, other->need_hard_reset_);
  swap(error_, other->error_);
}

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


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

void RequestStartReplay::InitAsDefaultInstance() {
  ::SC2APIProtocol::_RequestStartReplay_default_instance_.replay_path_.UnsafeSetDefault(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::SC2APIProtocol::_RequestStartReplay_default_instance_.replay_data_.UnsafeSetDefault(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::SC2APIProtocol::_RequestStartReplay_default_instance_._instance.get_mutable()->options_ = const_cast< ::SC2APIProtocol::InterfaceOptions*>(
      ::SC2APIProtocol::InterfaceOptions::internal_default_instance());
}
class RequestStartReplay::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestStartReplay>()._has_bits_);
  static void set_has_map_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_observed_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::InterfaceOptions& options(const RequestStartReplay* msg);
  static void set_has_options(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_disable_fog(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_realtime(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_record_replay(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::SC2APIProtocol::InterfaceOptions&
RequestStartReplay::_Internal::options(const RequestStartReplay* msg) {
  return *msg->options_;
}
RequestStartReplay::RequestStartReplay()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestStartReplay)
}
RequestStartReplay::RequestStartReplay(const RequestStartReplay& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  map_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_data()) {
    map_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_data_);
  }
  if (from._internal_has_options()) {
    options_ = new ::SC2APIProtocol::InterfaceOptions(*from.options_);
  } else {
    options_ = nullptr;
  }
  ::memcpy(&observed_player_id_, &from.observed_player_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&record_replay_) -
    reinterpret_cast<char*>(&observed_player_id_)) + sizeof(record_replay_));
  clear_has_replay();
  switch (from.replay_case()) {
    case kReplayPath: {
      _internal_set_replay_path(from._internal_replay_path());
      break;
    }
    case kReplayData: {
      _internal_set_replay_data(from._internal_replay_data());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestStartReplay)
}

void RequestStartReplay::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestStartReplay_s2clientprotocol_2fsc2api_2eproto.base);
  map_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&options_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&record_replay_) -
      reinterpret_cast<char*>(&options_)) + sizeof(record_replay_));
  clear_has_replay();
}

RequestStartReplay::~RequestStartReplay() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestStartReplay)
  SharedDtor();
}

void RequestStartReplay::SharedDtor() {
  map_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete options_;
  if (has_replay()) {
    clear_replay();
  }
}

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


void RequestStartReplay::clear_replay() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.RequestStartReplay)
  switch (replay_case()) {
    case kReplayPath: {
      replay_.replay_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kReplayData: {
      replay_.replay_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REPLAY_NOT_SET;
}


void RequestStartReplay::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.RequestStartReplay)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      map_data_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(options_ != nullptr);
      options_->Clear();
    }
  }
  if (cached_has_bits & 0x0000003cu) {
    ::memset(&observed_player_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&record_replay_) -
        reinterpret_cast<char*>(&observed_player_id_)) + sizeof(record_replay_));
  }
  clear_replay();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestStartReplay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string replay_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_replay_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestStartReplay.replay_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 observed_player_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_observed_player_id(&has_bits);
          observed_player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.InterfaceOptions options = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool disable_fog = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_disable_fog(&has_bits);
          disable_fog_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes replay_data = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_replay_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes map_data = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_map_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool realtime = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_realtime(&has_bits);
          realtime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool record_replay = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_record_replay(&has_bits);
          record_replay_ = ::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_, 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* RequestStartReplay::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.RequestStartReplay)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // optional string replay_path = 1;
  if (_internal_has_replay_path()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_replay_path().data(), static_cast<int>(this->_internal_replay_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.RequestStartReplay.replay_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_replay_path(), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional int32 observed_player_id = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_observed_player_id(), target);
  }

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

  // optional bool disable_fog = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_disable_fog(), target);
  }

  // optional bytes replay_data = 5;
  if (_internal_has_replay_data()) {
    target = stream->WriteBytesMaybeAliased(
        5, this->_internal_replay_data(), target);
  }

  // optional bytes map_data = 6;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        6, this->_internal_map_data(), target);
  }

  // optional bool realtime = 7;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_realtime(), target);
  }

  // optional bool record_replay = 8;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_record_replay(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestStartReplay)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional bytes map_data = 6;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_map_data());
    }

    // optional .SC2APIProtocol.InterfaceOptions options = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *options_);
    }

    // optional int32 observed_player_id = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_observed_player_id());
    }

    // optional bool disable_fog = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool realtime = 7;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool record_replay = 8;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

  }
  switch (replay_case()) {
    // optional string replay_path = 1;
    case kReplayPath: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_replay_path());
      break;
    }
    // optional bytes replay_data = 5;
    case kReplayData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_replay_data());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
  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 RequestStartReplay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestStartReplay)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestStartReplay* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestStartReplay>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestStartReplay)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestStartReplay)
    MergeFrom(*source);
  }
}

void RequestStartReplay::MergeFrom(const RequestStartReplay& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.RequestStartReplay)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      map_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_options()->::SC2APIProtocol::InterfaceOptions::MergeFrom(from._internal_options());
    }
    if (cached_has_bits & 0x00000004u) {
      observed_player_id_ = from.observed_player_id_;
    }
    if (cached_has_bits & 0x00000008u) {
      disable_fog_ = from.disable_fog_;
    }
    if (cached_has_bits & 0x00000010u) {
      realtime_ = from.realtime_;
    }
    if (cached_has_bits & 0x00000020u) {
      record_replay_ = from.record_replay_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.replay_case()) {
    case kReplayPath: {
      _internal_set_replay_path(from._internal_replay_path());
      break;
    }
    case kReplayData: {
      _internal_set_replay_data(from._internal_replay_data());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
}

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

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

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

void RequestStartReplay::InternalSwap(RequestStartReplay* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  map_data_.Swap(&other->map_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(options_, other->options_);
  swap(observed_player_id_, other->observed_player_id_);
  swap(disable_fog_, other->disable_fog_);
  swap(realtime_, other->realtime_);
  swap(record_replay_, other->record_replay_);
  swap(replay_, other->replay_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void ResponseStartReplay::InitAsDefaultInstance() {
}
class ResponseStartReplay::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseStartReplay>()._has_bits_);
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_error_details(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseStartReplay::ResponseStartReplay()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseStartReplay)
}
ResponseStartReplay::ResponseStartReplay(const ResponseStartReplay& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_details()) {
    error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
  }
  error_ = from.error_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseStartReplay)
}

void ResponseStartReplay::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseStartReplay_s2clientprotocol_2fsc2api_2eproto.base);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_ = 1;
}

ResponseStartReplay::~ResponseStartReplay() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseStartReplay)
  SharedDtor();
}

void ResponseStartReplay::SharedDtor() {
  error_details_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponseStartReplay::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponseStartReplay)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      error_details_.ClearNonDefaultToEmptyNoArena();
    }
    error_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseStartReplay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ResponseStartReplay.Error error = 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(::SC2APIProtocol::ResponseStartReplay_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseStartReplay_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string error_details = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_error_details();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseStartReplay.error_details");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ResponseStartReplay.Error error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_error(), target);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseStartReplay)
  return target;
}

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

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

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

    // optional .SC2APIProtocol.ResponseStartReplay.Error error = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  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 ResponseStartReplay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseStartReplay)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseStartReplay* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseStartReplay>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseStartReplay)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseStartReplay)
    MergeFrom(*source);
  }
}

void ResponseStartReplay::MergeFrom(const ResponseStartReplay& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ResponseStartReplay)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
    }
    if (cached_has_bits & 0x00000002u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponseStartReplay::InternalSwap(ResponseStartReplay* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_details_.Swap(&other->error_details_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(error_, other->error_);
}

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


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

void RequestMapCommand::InitAsDefaultInstance() {
}
class RequestMapCommand::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestMapCommand>()._has_bits_);
  static void set_has_trigger_cmd(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestMapCommand::RequestMapCommand()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestMapCommand)
}
RequestMapCommand::RequestMapCommand(const RequestMapCommand& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  trigger_cmd_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_trigger_cmd()) {
    trigger_cmd_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.trigger_cmd_);
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestMapCommand)
}

void RequestMapCommand::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestMapCommand_s2clientprotocol_2fsc2api_2eproto.base);
  trigger_cmd_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

RequestMapCommand::~RequestMapCommand() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestMapCommand)
  SharedDtor();
}

void RequestMapCommand::SharedDtor() {
  trigger_cmd_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void RequestMapCommand::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.RequestMapCommand)
  ::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 & 0x00000001u) {
    trigger_cmd_.ClearNonDefaultToEmptyNoArena();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestMapCommand::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string trigger_cmd = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_trigger_cmd();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestMapCommand.trigger_cmd");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional string trigger_cmd = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_trigger_cmd().data(), static_cast<int>(this->_internal_trigger_cmd().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.RequestMapCommand.trigger_cmd");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_trigger_cmd(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestMapCommand)
  return target;
}

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

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

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

  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 RequestMapCommand::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestMapCommand)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestMapCommand* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestMapCommand>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestMapCommand)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestMapCommand)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_trigger_cmd()) {
    _has_bits_[0] |= 0x00000001u;
    trigger_cmd_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.trigger_cmd_);
  }
}

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

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

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

void RequestMapCommand::InternalSwap(RequestMapCommand* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  trigger_cmd_.Swap(&other->trigger_cmd_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

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


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

void ResponseMapCommand::InitAsDefaultInstance() {
}
class ResponseMapCommand::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseMapCommand>()._has_bits_);
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_error_details(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseMapCommand::ResponseMapCommand()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseMapCommand)
}
ResponseMapCommand::ResponseMapCommand(const ResponseMapCommand& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_details()) {
    error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
  }
  error_ = from.error_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseMapCommand)
}

void ResponseMapCommand::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseMapCommand_s2clientprotocol_2fsc2api_2eproto.base);
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_ = 1;
}

ResponseMapCommand::~ResponseMapCommand() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseMapCommand)
  SharedDtor();
}

void ResponseMapCommand::SharedDtor() {
  error_details_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponseMapCommand::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponseMapCommand)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      error_details_.ClearNonDefaultToEmptyNoArena();
    }
    error_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseMapCommand::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ResponseMapCommand.Error error = 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(::SC2APIProtocol::ResponseMapCommand_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseMapCommand_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string error_details = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_error_details();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseMapCommand.error_details");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ResponseMapCommand.Error error = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_error(), target);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseMapCommand)
  return target;
}

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

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

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

    // optional .SC2APIProtocol.ResponseMapCommand.Error error = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  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 ResponseMapCommand::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseMapCommand)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseMapCommand* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseMapCommand>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseMapCommand)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseMapCommand)
    MergeFrom(*source);
  }
}

void ResponseMapCommand::MergeFrom(const ResponseMapCommand& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ResponseMapCommand)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
    }
    if (cached_has_bits & 0x00000002u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponseMapCommand::InternalSwap(ResponseMapCommand* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  error_details_.Swap(&other->error_details_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(error_, other->error_);
}

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


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

void RequestLeaveGame::InitAsDefaultInstance() {
}
class RequestLeaveGame::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestLeaveGame>()._has_bits_);
};

RequestLeaveGame::RequestLeaveGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestLeaveGame)
}
RequestLeaveGame::RequestLeaveGame(const RequestLeaveGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestLeaveGame)
}

void RequestLeaveGame::SharedCtor() {
}

RequestLeaveGame::~RequestLeaveGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestLeaveGame)
  SharedDtor();
}

void RequestLeaveGame::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestLeaveGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestLeaveGame)
  return target;
}

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

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

  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 RequestLeaveGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestLeaveGame)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestLeaveGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestLeaveGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestLeaveGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestLeaveGame)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestLeaveGame::InternalSwap(RequestLeaveGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseLeaveGame::InitAsDefaultInstance() {
}
class ResponseLeaveGame::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseLeaveGame>()._has_bits_);
};

ResponseLeaveGame::ResponseLeaveGame()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseLeaveGame)
}
ResponseLeaveGame::ResponseLeaveGame(const ResponseLeaveGame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseLeaveGame)
}

void ResponseLeaveGame::SharedCtor() {
}

ResponseLeaveGame::~ResponseLeaveGame() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseLeaveGame)
  SharedDtor();
}

void ResponseLeaveGame::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseLeaveGame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseLeaveGame)
  return target;
}

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

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

  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 ResponseLeaveGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseLeaveGame)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseLeaveGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseLeaveGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseLeaveGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseLeaveGame)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void ResponseLeaveGame::InternalSwap(ResponseLeaveGame* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void RequestQuickSave::InitAsDefaultInstance() {
}
class RequestQuickSave::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestQuickSave>()._has_bits_);
};

RequestQuickSave::RequestQuickSave()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestQuickSave)
}
RequestQuickSave::RequestQuickSave(const RequestQuickSave& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestQuickSave)
}

void RequestQuickSave::SharedCtor() {
}

RequestQuickSave::~RequestQuickSave() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestQuickSave)
  SharedDtor();
}

void RequestQuickSave::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestQuickSave::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestQuickSave)
  return target;
}

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

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

  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 RequestQuickSave::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestQuickSave)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestQuickSave* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestQuickSave>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestQuickSave)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestQuickSave)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestQuickSave::InternalSwap(RequestQuickSave* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseQuickSave::InitAsDefaultInstance() {
}
class ResponseQuickSave::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseQuickSave>()._has_bits_);
};

ResponseQuickSave::ResponseQuickSave()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseQuickSave)
}
ResponseQuickSave::ResponseQuickSave(const ResponseQuickSave& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseQuickSave)
}

void ResponseQuickSave::SharedCtor() {
}

ResponseQuickSave::~ResponseQuickSave() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseQuickSave)
  SharedDtor();
}

void ResponseQuickSave::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseQuickSave::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseQuickSave)
  return target;
}

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

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

  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 ResponseQuickSave::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseQuickSave)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseQuickSave* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseQuickSave>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseQuickSave)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseQuickSave)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void ResponseQuickSave::InternalSwap(ResponseQuickSave* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void RequestQuickLoad::InitAsDefaultInstance() {
}
class RequestQuickLoad::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestQuickLoad>()._has_bits_);
};

RequestQuickLoad::RequestQuickLoad()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestQuickLoad)
}
RequestQuickLoad::RequestQuickLoad(const RequestQuickLoad& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestQuickLoad)
}

void RequestQuickLoad::SharedCtor() {
}

RequestQuickLoad::~RequestQuickLoad() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestQuickLoad)
  SharedDtor();
}

void RequestQuickLoad::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestQuickLoad::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestQuickLoad)
  return target;
}

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

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

  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 RequestQuickLoad::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestQuickLoad)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestQuickLoad* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestQuickLoad>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestQuickLoad)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestQuickLoad)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestQuickLoad::InternalSwap(RequestQuickLoad* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseQuickLoad::InitAsDefaultInstance() {
}
class ResponseQuickLoad::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseQuickLoad>()._has_bits_);
};

ResponseQuickLoad::ResponseQuickLoad()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseQuickLoad)
}
ResponseQuickLoad::ResponseQuickLoad(const ResponseQuickLoad& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseQuickLoad)
}

void ResponseQuickLoad::SharedCtor() {
}

ResponseQuickLoad::~ResponseQuickLoad() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseQuickLoad)
  SharedDtor();
}

void ResponseQuickLoad::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseQuickLoad::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseQuickLoad)
  return target;
}

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

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

  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 ResponseQuickLoad::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseQuickLoad)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseQuickLoad* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseQuickLoad>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseQuickLoad)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseQuickLoad)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void ResponseQuickLoad::InternalSwap(ResponseQuickLoad* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void RequestQuit::InitAsDefaultInstance() {
}
class RequestQuit::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestQuit>()._has_bits_);
};

RequestQuit::RequestQuit()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestQuit)
}
RequestQuit::RequestQuit(const RequestQuit& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestQuit)
}

void RequestQuit::SharedCtor() {
}

RequestQuit::~RequestQuit() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestQuit)
  SharedDtor();
}

void RequestQuit::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestQuit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestQuit)
  return target;
}

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

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

  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 RequestQuit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestQuit)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestQuit* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestQuit>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestQuit)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestQuit)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestQuit::InternalSwap(RequestQuit* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseQuit::InitAsDefaultInstance() {
}
class ResponseQuit::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseQuit>()._has_bits_);
};

ResponseQuit::ResponseQuit()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseQuit)
}
ResponseQuit::ResponseQuit(const ResponseQuit& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseQuit)
}

void ResponseQuit::SharedCtor() {
}

ResponseQuit::~ResponseQuit() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseQuit)
  SharedDtor();
}

void ResponseQuit::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseQuit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseQuit)
  return target;
}

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

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

  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 ResponseQuit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseQuit)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseQuit* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseQuit>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseQuit)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseQuit)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void ResponseQuit::InternalSwap(ResponseQuit* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void RequestGameInfo::InitAsDefaultInstance() {
}
class RequestGameInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestGameInfo>()._has_bits_);
};

RequestGameInfo::RequestGameInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestGameInfo)
}
RequestGameInfo::RequestGameInfo(const RequestGameInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestGameInfo)
}

void RequestGameInfo::SharedCtor() {
}

RequestGameInfo::~RequestGameInfo() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestGameInfo)
  SharedDtor();
}

void RequestGameInfo::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestGameInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestGameInfo)
  return target;
}

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

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

  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 RequestGameInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestGameInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestGameInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestGameInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestGameInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestGameInfo)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestGameInfo::InternalSwap(RequestGameInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseGameInfo::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ResponseGameInfo_default_instance_._instance.get_mutable()->start_raw_ = const_cast< ::SC2APIProtocol::StartRaw*>(
      ::SC2APIProtocol::StartRaw::internal_default_instance());
  ::SC2APIProtocol::_ResponseGameInfo_default_instance_._instance.get_mutable()->options_ = const_cast< ::SC2APIProtocol::InterfaceOptions*>(
      ::SC2APIProtocol::InterfaceOptions::internal_default_instance());
}
class ResponseGameInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseGameInfo>()._has_bits_);
  static void set_has_map_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_local_map_path(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SC2APIProtocol::StartRaw& start_raw(const ResponseGameInfo* msg);
  static void set_has_start_raw(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::InterfaceOptions& options(const ResponseGameInfo* msg);
  static void set_has_options(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::SC2APIProtocol::StartRaw&
ResponseGameInfo::_Internal::start_raw(const ResponseGameInfo* msg) {
  return *msg->start_raw_;
}
const ::SC2APIProtocol::InterfaceOptions&
ResponseGameInfo::_Internal::options(const ResponseGameInfo* msg) {
  return *msg->options_;
}
void ResponseGameInfo::clear_start_raw() {
  if (start_raw_ != nullptr) start_raw_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
ResponseGameInfo::ResponseGameInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseGameInfo)
}
ResponseGameInfo::ResponseGameInfo(const ResponseGameInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      player_info_(from.player_info_),
      mod_names_(from.mod_names_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  map_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_name()) {
    map_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_name_);
  }
  local_map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_local_map_path()) {
    local_map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.local_map_path_);
  }
  if (from._internal_has_start_raw()) {
    start_raw_ = new ::SC2APIProtocol::StartRaw(*from.start_raw_);
  } else {
    start_raw_ = nullptr;
  }
  if (from._internal_has_options()) {
    options_ = new ::SC2APIProtocol::InterfaceOptions(*from.options_);
  } else {
    options_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseGameInfo)
}

void ResponseGameInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseGameInfo_s2clientprotocol_2fsc2api_2eproto.base);
  map_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  local_map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&start_raw_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&options_) -
      reinterpret_cast<char*>(&start_raw_)) + sizeof(options_));
}

ResponseGameInfo::~ResponseGameInfo() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseGameInfo)
  SharedDtor();
}

void ResponseGameInfo::SharedDtor() {
  map_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  local_map_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete start_raw_;
  if (this != internal_default_instance()) delete options_;
}

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


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

  player_info_.Clear();
  mod_names_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      map_name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      local_map_path_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(start_raw_ != nullptr);
      start_raw_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(options_ != nullptr);
      options_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseGameInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string map_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_map_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseGameInfo.map_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string local_map_path = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_local_map_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseGameInfo.local_map_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.PlayerInfo player_info = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_player_info(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.StartRaw start_raw = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_start_raw(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.InterfaceOptions options = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_options(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string mod_names = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_mod_names();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseGameInfo.mod_names");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, 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* ResponseGameInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ResponseGameInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string map_name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_map_name().data(), static_cast<int>(this->_internal_map_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseGameInfo.map_name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_map_name(), target);
  }

  // optional string local_map_path = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_local_map_path().data(), static_cast<int>(this->_internal_local_map_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseGameInfo.local_map_path");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_local_map_path(), target);
  }

  // repeated .SC2APIProtocol.PlayerInfo player_info = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_player_info_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_player_info(i), target, stream);
  }

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

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

  // repeated string mod_names = 6;
  for (int i = 0, n = this->_internal_mod_names_size(); i < n; i++) {
    const auto& s = this->_internal_mod_names(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseGameInfo.mod_names");
    target = stream->WriteString(6, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseGameInfo)
  return target;
}

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

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

  // repeated .SC2APIProtocol.PlayerInfo player_info = 3;
  total_size += 1UL * this->_internal_player_info_size();
  for (const auto& msg : this->player_info_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated string mod_names = 6;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(mod_names_.size());
  for (int i = 0, n = mod_names_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      mod_names_.Get(i));
  }

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

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

    // optional .SC2APIProtocol.StartRaw start_raw = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *start_raw_);
    }

    // optional .SC2APIProtocol.InterfaceOptions options = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *options_);
    }

  }
  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 ResponseGameInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseGameInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseGameInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseGameInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseGameInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseGameInfo)
    MergeFrom(*source);
  }
}

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

  player_info_.MergeFrom(from.player_info_);
  mod_names_.MergeFrom(from.mod_names_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      map_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      local_map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.local_map_path_);
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_start_raw()->::SC2APIProtocol::StartRaw::MergeFrom(from._internal_start_raw());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_options()->::SC2APIProtocol::InterfaceOptions::MergeFrom(from._internal_options());
    }
  }
}

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

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

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

void ResponseGameInfo::InternalSwap(ResponseGameInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  player_info_.InternalSwap(&other->player_info_);
  mod_names_.InternalSwap(&other->mod_names_);
  map_name_.Swap(&other->map_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  local_map_path_.Swap(&other->local_map_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(start_raw_, other->start_raw_);
  swap(options_, other->options_);
}

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


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

void RequestObservation::InitAsDefaultInstance() {
}
class RequestObservation::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestObservation>()._has_bits_);
  static void set_has_disable_fog(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_game_loop(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

RequestObservation::RequestObservation()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestObservation)
}
RequestObservation::RequestObservation(const RequestObservation& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&disable_fog_, &from.disable_fog_,
    static_cast<size_t>(reinterpret_cast<char*>(&game_loop_) -
    reinterpret_cast<char*>(&disable_fog_)) + sizeof(game_loop_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestObservation)
}

void RequestObservation::SharedCtor() {
  ::memset(&disable_fog_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&game_loop_) -
      reinterpret_cast<char*>(&disable_fog_)) + sizeof(game_loop_));
}

RequestObservation::~RequestObservation() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestObservation)
  SharedDtor();
}

void RequestObservation::SharedDtor() {
}

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


void RequestObservation::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.RequestObservation)
  ::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 & 0x00000003u) {
    ::memset(&disable_fog_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&game_loop_) -
        reinterpret_cast<char*>(&disable_fog_)) + sizeof(game_loop_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestObservation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool disable_fog = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_disable_fog(&has_bits);
          disable_fog_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 game_loop = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_game_loop(&has_bits);
          game_loop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional bool disable_fog = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_disable_fog(), target);
  }

  // optional uint32 game_loop = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_game_loop(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestObservation)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional bool disable_fog = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 1;
    }

    // optional uint32 game_loop = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_game_loop());
    }

  }
  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 RequestObservation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestObservation)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestObservation* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestObservation>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestObservation)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestObservation)
    MergeFrom(*source);
  }
}

void RequestObservation::MergeFrom(const RequestObservation& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.RequestObservation)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      disable_fog_ = from.disable_fog_;
    }
    if (cached_has_bits & 0x00000002u) {
      game_loop_ = from.game_loop_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void RequestObservation::InternalSwap(RequestObservation* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(disable_fog_, other->disable_fog_);
  swap(game_loop_, other->game_loop_);
}

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


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

void ResponseObservation::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ResponseObservation_default_instance_._instance.get_mutable()->observation_ = const_cast< ::SC2APIProtocol::Observation*>(
      ::SC2APIProtocol::Observation::internal_default_instance());
}
class ResponseObservation::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseObservation>()._has_bits_);
  static const ::SC2APIProtocol::Observation& observation(const ResponseObservation* msg);
  static void set_has_observation(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SC2APIProtocol::Observation&
ResponseObservation::_Internal::observation(const ResponseObservation* msg) {
  return *msg->observation_;
}
ResponseObservation::ResponseObservation()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseObservation)
}
ResponseObservation::ResponseObservation(const ResponseObservation& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      actions_(from.actions_),
      action_errors_(from.action_errors_),
      player_result_(from.player_result_),
      chat_(from.chat_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_observation()) {
    observation_ = new ::SC2APIProtocol::Observation(*from.observation_);
  } else {
    observation_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseObservation)
}

void ResponseObservation::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseObservation_s2clientprotocol_2fsc2api_2eproto.base);
  observation_ = nullptr;
}

ResponseObservation::~ResponseObservation() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseObservation)
  SharedDtor();
}

void ResponseObservation::SharedDtor() {
  if (this != internal_default_instance()) delete observation_;
}

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


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

  actions_.Clear();
  action_errors_.Clear();
  player_result_.Clear();
  chat_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(observation_ != nullptr);
    observation_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseObservation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.Action actions = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_actions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.ActionError action_errors = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_action_errors(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Observation observation = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_observation(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.PlayerResult player_result = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_player_result(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.ChatReceived chat = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_chat(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, 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* ResponseObservation::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ResponseObservation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .SC2APIProtocol.Action actions = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_actions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_actions(i), target, stream);
  }

  // repeated .SC2APIProtocol.ActionError action_errors = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_action_errors_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_action_errors(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.Observation observation = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::observation(this), target, stream);
  }

  // repeated .SC2APIProtocol.PlayerResult player_result = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_player_result_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_player_result(i), target, stream);
  }

  // repeated .SC2APIProtocol.ChatReceived chat = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_chat_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_chat(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseObservation)
  return target;
}

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

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

  // repeated .SC2APIProtocol.Action actions = 1;
  total_size += 1UL * this->_internal_actions_size();
  for (const auto& msg : this->actions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.ActionError action_errors = 2;
  total_size += 1UL * this->_internal_action_errors_size();
  for (const auto& msg : this->action_errors_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.PlayerResult player_result = 4;
  total_size += 1UL * this->_internal_player_result_size();
  for (const auto& msg : this->player_result_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.ChatReceived chat = 5;
  total_size += 1UL * this->_internal_chat_size();
  for (const auto& msg : this->chat_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional .SC2APIProtocol.Observation observation = 3;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *observation_);
  }

  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 ResponseObservation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseObservation)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseObservation* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseObservation>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseObservation)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseObservation)
    MergeFrom(*source);
  }
}

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

  actions_.MergeFrom(from.actions_);
  action_errors_.MergeFrom(from.action_errors_);
  player_result_.MergeFrom(from.player_result_);
  chat_.MergeFrom(from.chat_);
  if (from._internal_has_observation()) {
    _internal_mutable_observation()->::SC2APIProtocol::Observation::MergeFrom(from._internal_observation());
  }
}

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

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

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

void ResponseObservation::InternalSwap(ResponseObservation* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  actions_.InternalSwap(&other->actions_);
  action_errors_.InternalSwap(&other->action_errors_);
  player_result_.InternalSwap(&other->player_result_);
  chat_.InternalSwap(&other->chat_);
  swap(observation_, other->observation_);
}

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


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

void ChatReceived::InitAsDefaultInstance() {
}
class ChatReceived::_Internal {
 public:
  using HasBits = decltype(std::declval<ChatReceived>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_message(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ChatReceived::ChatReceived()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ChatReceived)
}
ChatReceived::ChatReceived(const ChatReceived& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_message()) {
    message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
  }
  player_id_ = from.player_id_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ChatReceived)
}

void ChatReceived::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ChatReceived_s2clientprotocol_2fsc2api_2eproto.base);
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  player_id_ = 0u;
}

ChatReceived::~ChatReceived() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ChatReceived)
  SharedDtor();
}

void ChatReceived::SharedDtor() {
  message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ChatReceived::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ChatReceived)
  ::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 & 0x00000001u) {
    message_.ClearNonDefaultToEmptyNoArena();
  }
  player_id_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ChatReceived::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string message = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_message();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ChatReceived.message");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ChatReceived)
  return target;
}

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

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

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

    // optional uint32 player_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_player_id());
    }

  }
  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 ChatReceived::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ChatReceived)
  GOOGLE_DCHECK_NE(&from, this);
  const ChatReceived* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ChatReceived>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ChatReceived)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ChatReceived)
    MergeFrom(*source);
  }
}

void ChatReceived::MergeFrom(const ChatReceived& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ChatReceived)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
    if (cached_has_bits & 0x00000002u) {
      player_id_ = from.player_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ChatReceived::InternalSwap(ChatReceived* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(player_id_, other->player_id_);
}

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


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

void RequestAction::InitAsDefaultInstance() {
}
class RequestAction::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestAction>()._has_bits_);
};

RequestAction::RequestAction()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestAction)
}
RequestAction::RequestAction(const RequestAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      actions_(from.actions_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestAction)
}

void RequestAction::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestAction_s2clientprotocol_2fsc2api_2eproto.base);
}

RequestAction::~RequestAction() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestAction)
  SharedDtor();
}

void RequestAction::SharedDtor() {
}

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


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

  actions_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.Action actions = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_actions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated .SC2APIProtocol.Action actions = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_actions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_actions(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestAction)
  return target;
}

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

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

  // repeated .SC2APIProtocol.Action actions = 1;
  total_size += 1UL * this->_internal_actions_size();
  for (const auto& msg : this->actions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 RequestAction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestAction)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestAction* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestAction>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestAction)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestAction)
    MergeFrom(*source);
  }
}

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

  actions_.MergeFrom(from.actions_);
}

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

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

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

void RequestAction::InternalSwap(RequestAction* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  actions_.InternalSwap(&other->actions_);
}

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


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

void ResponseAction::InitAsDefaultInstance() {
}
class ResponseAction::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseAction>()._has_bits_);
};

ResponseAction::ResponseAction()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseAction)
}
ResponseAction::ResponseAction(const ResponseAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      result_(from.result_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseAction)
}

void ResponseAction::SharedCtor() {
}

ResponseAction::~ResponseAction() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseAction)
  SharedDtor();
}

void ResponseAction::SharedDtor() {
}

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


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

  result_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.ActionResult result = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::ActionResult_IsValid(val))) {
              _internal_add_result(static_cast<::SC2APIProtocol::ActionResult>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_result(), ptr, ctx, ::SC2APIProtocol::ActionResult_IsValid, &_internal_metadata_, 1);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated .SC2APIProtocol.ActionResult result = 1;
  for (int i = 0, n = this->_internal_result_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        1, this->_internal_result(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseAction)
  return target;
}

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

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

  // repeated .SC2APIProtocol.ActionResult result = 1;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_result_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_result(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  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 ResponseAction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseAction)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseAction* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseAction>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseAction)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseAction)
    MergeFrom(*source);
  }
}

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

  result_.MergeFrom(from.result_);
}

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

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

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

void ResponseAction::InternalSwap(ResponseAction* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  result_.InternalSwap(&other->result_);
}

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


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

void RequestObserverAction::InitAsDefaultInstance() {
}
class RequestObserverAction::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestObserverAction>()._has_bits_);
};

RequestObserverAction::RequestObserverAction()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestObserverAction)
}
RequestObserverAction::RequestObserverAction(const RequestObserverAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      actions_(from.actions_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestObserverAction)
}

void RequestObserverAction::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestObserverAction_s2clientprotocol_2fsc2api_2eproto.base);
}

RequestObserverAction::~RequestObserverAction() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestObserverAction)
  SharedDtor();
}

void RequestObserverAction::SharedDtor() {
}

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


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

  actions_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestObserverAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.ObserverAction actions = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_actions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated .SC2APIProtocol.ObserverAction actions = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_actions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_actions(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestObserverAction)
  return target;
}

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

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

  // repeated .SC2APIProtocol.ObserverAction actions = 1;
  total_size += 1UL * this->_internal_actions_size();
  for (const auto& msg : this->actions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 RequestObserverAction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestObserverAction)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestObserverAction* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestObserverAction>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestObserverAction)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestObserverAction)
    MergeFrom(*source);
  }
}

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

  actions_.MergeFrom(from.actions_);
}

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

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

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

void RequestObserverAction::InternalSwap(RequestObserverAction* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  actions_.InternalSwap(&other->actions_);
}

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


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

void ResponseObserverAction::InitAsDefaultInstance() {
}
class ResponseObserverAction::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseObserverAction>()._has_bits_);
};

ResponseObserverAction::ResponseObserverAction()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseObserverAction)
}
ResponseObserverAction::ResponseObserverAction(const ResponseObserverAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseObserverAction)
}

void ResponseObserverAction::SharedCtor() {
}

ResponseObserverAction::~ResponseObserverAction() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseObserverAction)
  SharedDtor();
}

void ResponseObserverAction::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseObserverAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseObserverAction)
  return target;
}

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

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

  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 ResponseObserverAction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseObserverAction)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseObserverAction* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseObserverAction>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseObserverAction)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseObserverAction)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void ResponseObserverAction::InternalSwap(ResponseObserverAction* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void RequestStep::InitAsDefaultInstance() {
}
class RequestStep::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestStep>()._has_bits_);
  static void set_has_count(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestStep::RequestStep()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestStep)
}
RequestStep::RequestStep(const RequestStep& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  count_ = from.count_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestStep)
}

void RequestStep::SharedCtor() {
  count_ = 0u;
}

RequestStep::~RequestStep() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestStep)
  SharedDtor();
}

void RequestStep::SharedDtor() {
}

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


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

  count_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestStep::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 count = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_count(&has_bits);
          count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 count = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_count(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestStep)
  return target;
}

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

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

  // optional uint32 count = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_count());
  }

  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 RequestStep::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestStep)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestStep* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestStep>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestStep)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestStep)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_count()) {
    _internal_set_count(from._internal_count());
  }
}

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

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

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

void RequestStep::InternalSwap(RequestStep* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(count_, other->count_);
}

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


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

void ResponseStep::InitAsDefaultInstance() {
}
class ResponseStep::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseStep>()._has_bits_);
  static void set_has_simulation_loop(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseStep::ResponseStep()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseStep)
}
ResponseStep::ResponseStep(const ResponseStep& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  simulation_loop_ = from.simulation_loop_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseStep)
}

void ResponseStep::SharedCtor() {
  simulation_loop_ = 0u;
}

ResponseStep::~ResponseStep() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseStep)
  SharedDtor();
}

void ResponseStep::SharedDtor() {
}

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


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

  simulation_loop_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseStep::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 simulation_loop = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_simulation_loop(&has_bits);
          simulation_loop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 simulation_loop = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_simulation_loop(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseStep)
  return target;
}

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

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

  // optional uint32 simulation_loop = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_simulation_loop());
  }

  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 ResponseStep::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseStep)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseStep* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseStep>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseStep)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseStep)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_simulation_loop()) {
    _internal_set_simulation_loop(from._internal_simulation_loop());
  }
}

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

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

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

void ResponseStep::InternalSwap(ResponseStep* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(simulation_loop_, other->simulation_loop_);
}

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


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

void RequestData::InitAsDefaultInstance() {
}
class RequestData::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestData>()._has_bits_);
  static void set_has_ability_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_unit_type_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_upgrade_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_buff_id(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_effect_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

RequestData::RequestData()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestData)
}
RequestData::RequestData(const RequestData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ability_id_, &from.ability_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&effect_id_) -
    reinterpret_cast<char*>(&ability_id_)) + sizeof(effect_id_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestData)
}

void RequestData::SharedCtor() {
  ::memset(&ability_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&effect_id_) -
      reinterpret_cast<char*>(&ability_id_)) + sizeof(effect_id_));
}

RequestData::~RequestData() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestData)
  SharedDtor();
}

void RequestData::SharedDtor() {
}

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


void RequestData::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.RequestData)
  ::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 & 0x0000001fu) {
    ::memset(&ability_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&effect_id_) -
        reinterpret_cast<char*>(&ability_id_)) + sizeof(effect_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool ability_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ability_id(&has_bits);
          ability_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool unit_type_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_unit_type_id(&has_bits);
          unit_type_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool upgrade_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_upgrade_id(&has_bits);
          upgrade_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool buff_id = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_buff_id(&has_bits);
          buff_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool effect_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_effect_id(&has_bits);
          effect_id_ = ::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_, 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* RequestData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.RequestData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool ability_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_ability_id(), target);
  }

  // optional bool unit_type_id = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_unit_type_id(), target);
  }

  // optional bool upgrade_id = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_upgrade_id(), target);
  }

  // optional bool buff_id = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_buff_id(), target);
  }

  // optional bool effect_id = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_effect_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestData)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional bool ability_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 1;
    }

    // optional bool unit_type_id = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional bool upgrade_id = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

    // optional bool buff_id = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool effect_id = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  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 RequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestData)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestData* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestData>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestData)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestData)
    MergeFrom(*source);
  }
}

void RequestData::MergeFrom(const RequestData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.RequestData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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) {
      ability_id_ = from.ability_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      unit_type_id_ = from.unit_type_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      upgrade_id_ = from.upgrade_id_;
    }
    if (cached_has_bits & 0x00000008u) {
      buff_id_ = from.buff_id_;
    }
    if (cached_has_bits & 0x00000010u) {
      effect_id_ = from.effect_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void RequestData::InternalSwap(RequestData* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(ability_id_, other->ability_id_);
  swap(unit_type_id_, other->unit_type_id_);
  swap(upgrade_id_, other->upgrade_id_);
  swap(buff_id_, other->buff_id_);
  swap(effect_id_, other->effect_id_);
}

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


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

void ResponseData::InitAsDefaultInstance() {
}
class ResponseData::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseData>()._has_bits_);
};

void ResponseData::clear_abilities() {
  abilities_.Clear();
}
void ResponseData::clear_units() {
  units_.Clear();
}
void ResponseData::clear_upgrades() {
  upgrades_.Clear();
}
void ResponseData::clear_buffs() {
  buffs_.Clear();
}
void ResponseData::clear_effects() {
  effects_.Clear();
}
ResponseData::ResponseData()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseData)
}
ResponseData::ResponseData(const ResponseData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      abilities_(from.abilities_),
      units_(from.units_),
      upgrades_(from.upgrades_),
      buffs_(from.buffs_),
      effects_(from.effects_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseData)
}

void ResponseData::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseData_s2clientprotocol_2fsc2api_2eproto.base);
}

ResponseData::~ResponseData() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseData)
  SharedDtor();
}

void ResponseData::SharedDtor() {
}

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


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

  abilities_.Clear();
  units_.Clear();
  upgrades_.Clear();
  buffs_.Clear();
  effects_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.AbilityData abilities = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_abilities(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.UnitTypeData units = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_units(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.UpgradeData upgrades = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_upgrades(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.BuffData buffs = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_buffs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.EffectData effects = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_effects(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated .SC2APIProtocol.AbilityData abilities = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_abilities_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_abilities(i), target, stream);
  }

  // repeated .SC2APIProtocol.UnitTypeData units = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_units_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_units(i), target, stream);
  }

  // repeated .SC2APIProtocol.UpgradeData upgrades = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_upgrades_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_upgrades(i), target, stream);
  }

  // repeated .SC2APIProtocol.BuffData buffs = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_buffs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_buffs(i), target, stream);
  }

  // repeated .SC2APIProtocol.EffectData effects = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_effects_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_effects(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseData)
  return target;
}

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

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

  // repeated .SC2APIProtocol.AbilityData abilities = 1;
  total_size += 1UL * this->_internal_abilities_size();
  for (const auto& msg : this->abilities_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.UnitTypeData units = 2;
  total_size += 1UL * this->_internal_units_size();
  for (const auto& msg : this->units_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.UpgradeData upgrades = 3;
  total_size += 1UL * this->_internal_upgrades_size();
  for (const auto& msg : this->upgrades_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.BuffData buffs = 4;
  total_size += 1UL * this->_internal_buffs_size();
  for (const auto& msg : this->buffs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.EffectData effects = 5;
  total_size += 1UL * this->_internal_effects_size();
  for (const auto& msg : this->effects_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 ResponseData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseData)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseData* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseData>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseData)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseData)
    MergeFrom(*source);
  }
}

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

  abilities_.MergeFrom(from.abilities_);
  units_.MergeFrom(from.units_);
  upgrades_.MergeFrom(from.upgrades_);
  buffs_.MergeFrom(from.buffs_);
  effects_.MergeFrom(from.effects_);
}

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

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

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

void ResponseData::InternalSwap(ResponseData* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  abilities_.InternalSwap(&other->abilities_);
  units_.InternalSwap(&other->units_);
  upgrades_.InternalSwap(&other->upgrades_);
  buffs_.InternalSwap(&other->buffs_);
  effects_.InternalSwap(&other->effects_);
}

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


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

void RequestSaveReplay::InitAsDefaultInstance() {
}
class RequestSaveReplay::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestSaveReplay>()._has_bits_);
};

RequestSaveReplay::RequestSaveReplay()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestSaveReplay)
}
RequestSaveReplay::RequestSaveReplay(const RequestSaveReplay& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestSaveReplay)
}

void RequestSaveReplay::SharedCtor() {
}

RequestSaveReplay::~RequestSaveReplay() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestSaveReplay)
  SharedDtor();
}

void RequestSaveReplay::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestSaveReplay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestSaveReplay)
  return target;
}

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

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

  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 RequestSaveReplay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestSaveReplay)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestSaveReplay* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestSaveReplay>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestSaveReplay)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestSaveReplay)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestSaveReplay::InternalSwap(RequestSaveReplay* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseSaveReplay::InitAsDefaultInstance() {
}
class ResponseSaveReplay::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseSaveReplay>()._has_bits_);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseSaveReplay::ResponseSaveReplay()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseSaveReplay)
}
ResponseSaveReplay::ResponseSaveReplay(const ResponseSaveReplay& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseSaveReplay)
}

void ResponseSaveReplay::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseSaveReplay_s2clientprotocol_2fsc2api_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

ResponseSaveReplay::~ResponseSaveReplay() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseSaveReplay)
  SharedDtor();
}

void ResponseSaveReplay::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponseSaveReplay::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponseSaveReplay)
  ::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 & 0x00000001u) {
    data_.ClearNonDefaultToEmptyNoArena();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseSaveReplay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bytes data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional bytes data = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseSaveReplay)
  return target;
}

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

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

  // optional bytes data = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_data());
  }

  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 ResponseSaveReplay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseSaveReplay)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseSaveReplay* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseSaveReplay>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseSaveReplay)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseSaveReplay)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_data()) {
    _has_bits_[0] |= 0x00000001u;
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
}

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

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

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

void ResponseSaveReplay::InternalSwap(ResponseSaveReplay* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

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


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

void RequestReplayInfo::InitAsDefaultInstance() {
  ::SC2APIProtocol::_RequestReplayInfo_default_instance_.replay_path_.UnsafeSetDefault(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::SC2APIProtocol::_RequestReplayInfo_default_instance_.replay_data_.UnsafeSetDefault(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
class RequestReplayInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestReplayInfo>()._has_bits_);
  static void set_has_download_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RequestReplayInfo::RequestReplayInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestReplayInfo)
}
RequestReplayInfo::RequestReplayInfo(const RequestReplayInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  download_data_ = from.download_data_;
  clear_has_replay();
  switch (from.replay_case()) {
    case kReplayPath: {
      _internal_set_replay_path(from._internal_replay_path());
      break;
    }
    case kReplayData: {
      _internal_set_replay_data(from._internal_replay_data());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestReplayInfo)
}

void RequestReplayInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestReplayInfo_s2clientprotocol_2fsc2api_2eproto.base);
  download_data_ = false;
  clear_has_replay();
}

RequestReplayInfo::~RequestReplayInfo() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestReplayInfo)
  SharedDtor();
}

void RequestReplayInfo::SharedDtor() {
  if (has_replay()) {
    clear_replay();
  }
}

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


void RequestReplayInfo::clear_replay() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.RequestReplayInfo)
  switch (replay_case()) {
    case kReplayPath: {
      replay_.replay_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kReplayData: {
      replay_.replay_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REPLAY_NOT_SET;
}


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

  download_data_ = false;
  clear_replay();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestReplayInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string replay_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_replay_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestReplayInfo.replay_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes replay_data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_replay_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool download_data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_download_data(&has_bits);
          download_data_ = ::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_, 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* RequestReplayInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.RequestReplayInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (replay_case()) {
    case kReplayPath: {
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
        this->_internal_replay_path().data(), static_cast<int>(this->_internal_replay_path().length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
        "SC2APIProtocol.RequestReplayInfo.replay_path");
      target = stream->WriteStringMaybeAliased(
          1, this->_internal_replay_path(), target);
      break;
    }
    case kReplayData: {
      target = stream->WriteBytesMaybeAliased(
          2, this->_internal_replay_data(), target);
      break;
    }
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional bool download_data = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_download_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestReplayInfo)
  return target;
}

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

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

  // optional bool download_data = 3;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  switch (replay_case()) {
    // optional string replay_path = 1;
    case kReplayPath: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_replay_path());
      break;
    }
    // optional bytes replay_data = 2;
    case kReplayData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_replay_data());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
  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 RequestReplayInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestReplayInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestReplayInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestReplayInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestReplayInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestReplayInfo)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_download_data()) {
    _internal_set_download_data(from._internal_download_data());
  }
  switch (from.replay_case()) {
    case kReplayPath: {
      _internal_set_replay_path(from._internal_replay_path());
      break;
    }
    case kReplayData: {
      _internal_set_replay_data(from._internal_replay_data());
      break;
    }
    case REPLAY_NOT_SET: {
      break;
    }
  }
}

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

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

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

void RequestReplayInfo::InternalSwap(RequestReplayInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(download_data_, other->download_data_);
  swap(replay_, other->replay_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void PlayerInfoExtra::InitAsDefaultInstance() {
  ::SC2APIProtocol::_PlayerInfoExtra_default_instance_._instance.get_mutable()->player_info_ = const_cast< ::SC2APIProtocol::PlayerInfo*>(
      ::SC2APIProtocol::PlayerInfo::internal_default_instance());
  ::SC2APIProtocol::_PlayerInfoExtra_default_instance_._instance.get_mutable()->player_result_ = const_cast< ::SC2APIProtocol::PlayerResult*>(
      ::SC2APIProtocol::PlayerResult::internal_default_instance());
}
class PlayerInfoExtra::_Internal {
 public:
  using HasBits = decltype(std::declval<PlayerInfoExtra>()._has_bits_);
  static const ::SC2APIProtocol::PlayerInfo& player_info(const PlayerInfoExtra* msg);
  static void set_has_player_info(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::PlayerResult& player_result(const PlayerInfoExtra* msg);
  static void set_has_player_result(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_player_mmr(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_player_apm(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::SC2APIProtocol::PlayerInfo&
PlayerInfoExtra::_Internal::player_info(const PlayerInfoExtra* msg) {
  return *msg->player_info_;
}
const ::SC2APIProtocol::PlayerResult&
PlayerInfoExtra::_Internal::player_result(const PlayerInfoExtra* msg) {
  return *msg->player_result_;
}
PlayerInfoExtra::PlayerInfoExtra()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.PlayerInfoExtra)
}
PlayerInfoExtra::PlayerInfoExtra(const PlayerInfoExtra& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_player_info()) {
    player_info_ = new ::SC2APIProtocol::PlayerInfo(*from.player_info_);
  } else {
    player_info_ = nullptr;
  }
  if (from._internal_has_player_result()) {
    player_result_ = new ::SC2APIProtocol::PlayerResult(*from.player_result_);
  } else {
    player_result_ = nullptr;
  }
  ::memcpy(&player_mmr_, &from.player_mmr_,
    static_cast<size_t>(reinterpret_cast<char*>(&player_apm_) -
    reinterpret_cast<char*>(&player_mmr_)) + sizeof(player_apm_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.PlayerInfoExtra)
}

void PlayerInfoExtra::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PlayerInfoExtra_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&player_info_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&player_apm_) -
      reinterpret_cast<char*>(&player_info_)) + sizeof(player_apm_));
}

PlayerInfoExtra::~PlayerInfoExtra() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.PlayerInfoExtra)
  SharedDtor();
}

void PlayerInfoExtra::SharedDtor() {
  if (this != internal_default_instance()) delete player_info_;
  if (this != internal_default_instance()) delete player_result_;
}

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


void PlayerInfoExtra::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.PlayerInfoExtra)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(player_info_ != nullptr);
      player_info_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(player_result_ != nullptr);
      player_result_->Clear();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&player_mmr_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&player_apm_) -
        reinterpret_cast<char*>(&player_mmr_)) + sizeof(player_apm_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* PlayerInfoExtra::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.PlayerInfo player_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.PlayerResult player_result = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_result(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 player_mmr = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_player_mmr(&has_bits);
          player_mmr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 player_apm = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_player_apm(&has_bits);
          player_apm_ = ::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_, 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* PlayerInfoExtra::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.PlayerInfoExtra)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.PlayerInfo player_info = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::player_info(this), target, stream);
  }

  // optional .SC2APIProtocol.PlayerResult player_result = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::player_result(this), target, stream);
  }

  // optional int32 player_mmr = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_player_mmr(), target);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.PlayerInfoExtra)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional .SC2APIProtocol.PlayerInfo player_info = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_info_);
    }

    // optional .SC2APIProtocol.PlayerResult player_result = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_result_);
    }

    // optional int32 player_mmr = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_player_mmr());
    }

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

  }
  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 PlayerInfoExtra::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.PlayerInfoExtra)
  GOOGLE_DCHECK_NE(&from, this);
  const PlayerInfoExtra* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PlayerInfoExtra>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.PlayerInfoExtra)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.PlayerInfoExtra)
    MergeFrom(*source);
  }
}

void PlayerInfoExtra::MergeFrom(const PlayerInfoExtra& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.PlayerInfoExtra)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_player_info()->::SC2APIProtocol::PlayerInfo::MergeFrom(from._internal_player_info());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_player_result()->::SC2APIProtocol::PlayerResult::MergeFrom(from._internal_player_result());
    }
    if (cached_has_bits & 0x00000004u) {
      player_mmr_ = from.player_mmr_;
    }
    if (cached_has_bits & 0x00000008u) {
      player_apm_ = from.player_apm_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void PlayerInfoExtra::InternalSwap(PlayerInfoExtra* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(player_info_, other->player_info_);
  swap(player_result_, other->player_result_);
  swap(player_mmr_, other->player_mmr_);
  swap(player_apm_, other->player_apm_);
}

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


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

void ResponseReplayInfo::InitAsDefaultInstance() {
}
class ResponseReplayInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseReplayInfo>()._has_bits_);
  static void set_has_map_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_local_map_path(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_game_duration_loops(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_game_duration_seconds(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_game_version(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_data_version(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_data_build(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_base_build(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_error_details(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

ResponseReplayInfo::ResponseReplayInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseReplayInfo)
}
ResponseReplayInfo::ResponseReplayInfo(const ResponseReplayInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      player_info_(from.player_info_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  map_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_name()) {
    map_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_name_);
  }
  local_map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_local_map_path()) {
    local_map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.local_map_path_);
  }
  game_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_game_version()) {
    game_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.game_version_);
  }
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_error_details()) {
    error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
  }
  data_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data_version()) {
    data_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_version_);
  }
  ::memcpy(&game_duration_loops_, &from.game_duration_loops_,
    static_cast<size_t>(reinterpret_cast<char*>(&error_) -
    reinterpret_cast<char*>(&game_duration_loops_)) + sizeof(error_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseReplayInfo)
}

void ResponseReplayInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseReplayInfo_s2clientprotocol_2fsc2api_2eproto.base);
  map_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  local_map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  game_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_details_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  data_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&game_duration_loops_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&base_build_) -
      reinterpret_cast<char*>(&game_duration_loops_)) + sizeof(base_build_));
  error_ = 1;
}

ResponseReplayInfo::~ResponseReplayInfo() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseReplayInfo)
  SharedDtor();
}

void ResponseReplayInfo::SharedDtor() {
  map_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  local_map_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  game_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  error_details_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  data_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


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

  player_info_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      map_name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      local_map_path_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      game_version_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000008u) {
      error_details_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000010u) {
      data_version_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x000000e0u) {
    ::memset(&game_duration_loops_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&data_build_) -
        reinterpret_cast<char*>(&game_duration_loops_)) + sizeof(data_build_));
  }
  if (cached_has_bits & 0x00000300u) {
    base_build_ = 0u;
    error_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseReplayInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string map_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_map_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseReplayInfo.map_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string local_map_path = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_local_map_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseReplayInfo.local_map_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.PlayerInfoExtra player_info = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_player_info(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional uint32 game_duration_loops = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_game_duration_loops(&has_bits);
          game_duration_loops_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float game_duration_seconds = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          _Internal::set_has_game_duration_seconds(&has_bits);
          game_duration_seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional string game_version = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_game_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseReplayInfo.game_version");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 data_build = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_data_build(&has_bits);
          data_build_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 base_build = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_base_build(&has_bits);
          base_build_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ResponseReplayInfo.Error error = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::ResponseReplayInfo_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseReplayInfo_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string error_details = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          auto str = _internal_mutable_error_details();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseReplayInfo.error_details");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string data_version = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          auto str = _internal_mutable_data_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseReplayInfo.data_version");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional string map_name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_map_name().data(), static_cast<int>(this->_internal_map_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseReplayInfo.map_name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_map_name(), target);
  }

  // optional string local_map_path = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_local_map_path().data(), static_cast<int>(this->_internal_local_map_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseReplayInfo.local_map_path");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_local_map_path(), target);
  }

  // repeated .SC2APIProtocol.PlayerInfoExtra player_info = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_player_info_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_player_info(i), target, stream);
  }

  // optional uint32 game_duration_loops = 4;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_game_duration_loops(), target);
  }

  // optional float game_duration_seconds = 5;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_game_duration_seconds(), target);
  }

  // optional string game_version = 6;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_game_version().data(), static_cast<int>(this->_internal_game_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseReplayInfo.game_version");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_game_version(), target);
  }

  // optional uint32 data_build = 7;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_data_build(), target);
  }

  // optional uint32 base_build = 8;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_base_build(), target);
  }

  // optional .SC2APIProtocol.ResponseReplayInfo.Error error = 9;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      9, this->_internal_error(), target);
  }

  // optional string error_details = 10;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_error_details().data(), static_cast<int>(this->_internal_error_details().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseReplayInfo.error_details");
    target = stream->WriteStringMaybeAliased(
        10, this->_internal_error_details(), target);
  }

  // optional string data_version = 11;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_data_version().data(), static_cast<int>(this->_internal_data_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseReplayInfo.data_version");
    target = stream->WriteStringMaybeAliased(
        11, this->_internal_data_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseReplayInfo)
  return target;
}

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

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

  // repeated .SC2APIProtocol.PlayerInfoExtra player_info = 3;
  total_size += 1UL * this->_internal_player_info_size();
  for (const auto& msg : this->player_info_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

    // optional string game_version = 6;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_game_version());
    }

    // optional string error_details = 10;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_error_details());
    }

    // optional string data_version = 11;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_data_version());
    }

    // optional uint32 game_duration_loops = 4;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_game_duration_loops());
    }

    // optional float game_duration_seconds = 5;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 4;
    }

    // optional uint32 data_build = 7;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_data_build());
    }

  }
  if (cached_has_bits & 0x00000300u) {
    // optional uint32 base_build = 8;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_base_build());
    }

    // optional .SC2APIProtocol.ResponseReplayInfo.Error error = 9;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
    }

  }
  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 ResponseReplayInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseReplayInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseReplayInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseReplayInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseReplayInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseReplayInfo)
    MergeFrom(*source);
  }
}

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

  player_info_.MergeFrom(from.player_info_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      map_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      local_map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.local_map_path_);
    }
    if (cached_has_bits & 0x00000004u) {
      _has_bits_[0] |= 0x00000004u;
      game_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.game_version_);
    }
    if (cached_has_bits & 0x00000008u) {
      _has_bits_[0] |= 0x00000008u;
      error_details_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.error_details_);
    }
    if (cached_has_bits & 0x00000010u) {
      _has_bits_[0] |= 0x00000010u;
      data_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_version_);
    }
    if (cached_has_bits & 0x00000020u) {
      game_duration_loops_ = from.game_duration_loops_;
    }
    if (cached_has_bits & 0x00000040u) {
      game_duration_seconds_ = from.game_duration_seconds_;
    }
    if (cached_has_bits & 0x00000080u) {
      data_build_ = from.data_build_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000300u) {
    if (cached_has_bits & 0x00000100u) {
      base_build_ = from.base_build_;
    }
    if (cached_has_bits & 0x00000200u) {
      error_ = from.error_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponseReplayInfo::InternalSwap(ResponseReplayInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  player_info_.InternalSwap(&other->player_info_);
  map_name_.Swap(&other->map_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  local_map_path_.Swap(&other->local_map_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  game_version_.Swap(&other->game_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  error_details_.Swap(&other->error_details_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  data_version_.Swap(&other->data_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(game_duration_loops_, other->game_duration_loops_);
  swap(game_duration_seconds_, other->game_duration_seconds_);
  swap(data_build_, other->data_build_);
  swap(base_build_, other->base_build_);
  swap(error_, other->error_);
}

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


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

void RequestAvailableMaps::InitAsDefaultInstance() {
}
class RequestAvailableMaps::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestAvailableMaps>()._has_bits_);
};

RequestAvailableMaps::RequestAvailableMaps()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestAvailableMaps)
}
RequestAvailableMaps::RequestAvailableMaps(const RequestAvailableMaps& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestAvailableMaps)
}

void RequestAvailableMaps::SharedCtor() {
}

RequestAvailableMaps::~RequestAvailableMaps() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestAvailableMaps)
  SharedDtor();
}

void RequestAvailableMaps::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestAvailableMaps::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestAvailableMaps)
  return target;
}

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

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

  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 RequestAvailableMaps::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestAvailableMaps)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestAvailableMaps* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestAvailableMaps>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestAvailableMaps)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestAvailableMaps)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestAvailableMaps::InternalSwap(RequestAvailableMaps* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponseAvailableMaps::InitAsDefaultInstance() {
}
class ResponseAvailableMaps::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseAvailableMaps>()._has_bits_);
};

ResponseAvailableMaps::ResponseAvailableMaps()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseAvailableMaps)
}
ResponseAvailableMaps::ResponseAvailableMaps(const ResponseAvailableMaps& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      local_map_paths_(from.local_map_paths_),
      battlenet_map_names_(from.battlenet_map_names_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseAvailableMaps)
}

void ResponseAvailableMaps::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponseAvailableMaps_s2clientprotocol_2fsc2api_2eproto.base);
}

ResponseAvailableMaps::~ResponseAvailableMaps() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseAvailableMaps)
  SharedDtor();
}

void ResponseAvailableMaps::SharedDtor() {
}

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


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

  local_map_paths_.Clear();
  battlenet_map_names_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseAvailableMaps::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string local_map_paths = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_local_map_paths();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseAvailableMaps.local_map_paths");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated string battlenet_map_names = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_battlenet_map_names();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponseAvailableMaps.battlenet_map_names");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated string local_map_paths = 1;
  for (int i = 0, n = this->_internal_local_map_paths_size(); i < n; i++) {
    const auto& s = this->_internal_local_map_paths(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseAvailableMaps.local_map_paths");
    target = stream->WriteString(1, s, target);
  }

  // repeated string battlenet_map_names = 2;
  for (int i = 0, n = this->_internal_battlenet_map_names_size(); i < n; i++) {
    const auto& s = this->_internal_battlenet_map_names(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponseAvailableMaps.battlenet_map_names");
    target = stream->WriteString(2, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseAvailableMaps)
  return target;
}

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

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

  // repeated string local_map_paths = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(local_map_paths_.size());
  for (int i = 0, n = local_map_paths_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      local_map_paths_.Get(i));
  }

  // repeated string battlenet_map_names = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(battlenet_map_names_.size());
  for (int i = 0, n = battlenet_map_names_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      battlenet_map_names_.Get(i));
  }

  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 ResponseAvailableMaps::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseAvailableMaps)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseAvailableMaps* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseAvailableMaps>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseAvailableMaps)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseAvailableMaps)
    MergeFrom(*source);
  }
}

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

  local_map_paths_.MergeFrom(from.local_map_paths_);
  battlenet_map_names_.MergeFrom(from.battlenet_map_names_);
}

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

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

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

void ResponseAvailableMaps::InternalSwap(ResponseAvailableMaps* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  local_map_paths_.InternalSwap(&other->local_map_paths_);
  battlenet_map_names_.InternalSwap(&other->battlenet_map_names_);
}

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


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

void RequestSaveMap::InitAsDefaultInstance() {
}
class RequestSaveMap::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestSaveMap>()._has_bits_);
  static void set_has_map_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_map_data(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

RequestSaveMap::RequestSaveMap()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestSaveMap)
}
RequestSaveMap::RequestSaveMap(const RequestSaveMap& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_path()) {
    map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_path_);
  }
  map_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_map_data()) {
    map_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_data_);
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestSaveMap)
}

void RequestSaveMap::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestSaveMap_s2clientprotocol_2fsc2api_2eproto.base);
  map_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  map_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

RequestSaveMap::~RequestSaveMap() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestSaveMap)
  SharedDtor();
}

void RequestSaveMap::SharedDtor() {
  map_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  map_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void RequestSaveMap::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.RequestSaveMap)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      map_path_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      map_data_.ClearNonDefaultToEmptyNoArena();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestSaveMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string map_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_map_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.RequestSaveMap.map_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes map_data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_map_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional string map_path = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_map_path().data(), static_cast<int>(this->_internal_map_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.RequestSaveMap.map_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_map_path(), target);
  }

  // optional bytes map_data = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_map_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestSaveMap)
  return target;
}

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

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

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

    // optional bytes map_data = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_map_data());
    }

  }
  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 RequestSaveMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestSaveMap)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestSaveMap* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestSaveMap>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestSaveMap)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestSaveMap)
    MergeFrom(*source);
  }
}

void RequestSaveMap::MergeFrom(const RequestSaveMap& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.RequestSaveMap)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      map_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_path_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      map_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.map_data_);
    }
  }
}

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

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

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

void RequestSaveMap::InternalSwap(RequestSaveMap* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  map_path_.Swap(&other->map_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  map_data_.Swap(&other->map_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

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


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

void ResponseSaveMap::InitAsDefaultInstance() {
}
class ResponseSaveMap::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseSaveMap>()._has_bits_);
  static void set_has_error(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ResponseSaveMap::ResponseSaveMap()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseSaveMap)
}
ResponseSaveMap::ResponseSaveMap(const ResponseSaveMap& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_ = from.error_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseSaveMap)
}

void ResponseSaveMap::SharedCtor() {
  error_ = 1;
}

ResponseSaveMap::~ResponseSaveMap() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseSaveMap)
  SharedDtor();
}

void ResponseSaveMap::SharedDtor() {
}

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


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

  error_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseSaveMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ResponseSaveMap.Error error = 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(::SC2APIProtocol::ResponseSaveMap_Error_IsValid(val))) {
            _internal_set_error(static_cast<::SC2APIProtocol::ResponseSaveMap_Error>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ResponseSaveMap.Error error = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_error(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseSaveMap)
  return target;
}

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

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

  // optional .SC2APIProtocol.ResponseSaveMap.Error error = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error());
  }

  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 ResponseSaveMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseSaveMap)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseSaveMap* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseSaveMap>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseSaveMap)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseSaveMap)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_error()) {
    _internal_set_error(from._internal_error());
  }
}

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

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

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

void ResponseSaveMap::InternalSwap(ResponseSaveMap* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(error_, other->error_);
}

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


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

void RequestPing::InitAsDefaultInstance() {
}
class RequestPing::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestPing>()._has_bits_);
};

RequestPing::RequestPing()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestPing)
}
RequestPing::RequestPing(const RequestPing& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestPing)
}

void RequestPing::SharedCtor() {
}

RequestPing::~RequestPing() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestPing)
  SharedDtor();
}

void RequestPing::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestPing::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestPing)
  return target;
}

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

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

  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 RequestPing::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestPing)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestPing* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestPing>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestPing)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestPing)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void RequestPing::InternalSwap(RequestPing* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void ResponsePing::InitAsDefaultInstance() {
}
class ResponsePing::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponsePing>()._has_bits_);
  static void set_has_game_version(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_data_version(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data_build(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_base_build(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

ResponsePing::ResponsePing()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponsePing)
}
ResponsePing::ResponsePing(const ResponsePing& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  game_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_game_version()) {
    game_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.game_version_);
  }
  data_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data_version()) {
    data_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_version_);
  }
  ::memcpy(&data_build_, &from.data_build_,
    static_cast<size_t>(reinterpret_cast<char*>(&base_build_) -
    reinterpret_cast<char*>(&data_build_)) + sizeof(base_build_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponsePing)
}

void ResponsePing::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ResponsePing_s2clientprotocol_2fsc2api_2eproto.base);
  game_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  data_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&data_build_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&base_build_) -
      reinterpret_cast<char*>(&data_build_)) + sizeof(base_build_));
}

ResponsePing::~ResponsePing() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponsePing)
  SharedDtor();
}

void ResponsePing::SharedDtor() {
  game_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  data_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ResponsePing::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ResponsePing)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      game_version_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      data_version_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&data_build_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&base_build_) -
        reinterpret_cast<char*>(&data_build_)) + sizeof(base_build_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponsePing::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string game_version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_game_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponsePing.game_version");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string data_version = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_data_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ResponsePing.data_version");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 data_build = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_data_build(&has_bits);
          data_build_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 base_build = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_base_build(&has_bits);
          base_build_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional string game_version = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_game_version().data(), static_cast<int>(this->_internal_game_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponsePing.game_version");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_game_version(), target);
  }

  // optional string data_version = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_data_version().data(), static_cast<int>(this->_internal_data_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.ResponsePing.data_version");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_data_version(), target);
  }

  // optional uint32 data_build = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_data_build(), target);
  }

  // optional uint32 base_build = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_base_build(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponsePing)
  return target;
}

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

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

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

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

    // optional uint32 data_build = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_data_build());
    }

    // optional uint32 base_build = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_base_build());
    }

  }
  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 ResponsePing::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponsePing)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponsePing* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponsePing>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponsePing)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponsePing)
    MergeFrom(*source);
  }
}

void ResponsePing::MergeFrom(const ResponsePing& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ResponsePing)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      game_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.game_version_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      data_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_version_);
    }
    if (cached_has_bits & 0x00000004u) {
      data_build_ = from.data_build_;
    }
    if (cached_has_bits & 0x00000008u) {
      base_build_ = from.base_build_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ResponsePing::InternalSwap(ResponsePing* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  game_version_.Swap(&other->game_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  data_version_.Swap(&other->data_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(data_build_, other->data_build_);
  swap(base_build_, other->base_build_);
}

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


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

void RequestDebug::InitAsDefaultInstance() {
}
class RequestDebug::_Internal {
 public:
  using HasBits = decltype(std::declval<RequestDebug>()._has_bits_);
};

void RequestDebug::clear_debug() {
  debug_.Clear();
}
RequestDebug::RequestDebug()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RequestDebug)
}
RequestDebug::RequestDebug(const RequestDebug& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      debug_(from.debug_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RequestDebug)
}

void RequestDebug::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RequestDebug_s2clientprotocol_2fsc2api_2eproto.base);
}

RequestDebug::~RequestDebug() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.RequestDebug)
  SharedDtor();
}

void RequestDebug::SharedDtor() {
}

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


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

  debug_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* RequestDebug::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.DebugCommand debug = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_debug(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated .SC2APIProtocol.DebugCommand debug = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_debug_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_debug(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.RequestDebug)
  return target;
}

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

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

  // repeated .SC2APIProtocol.DebugCommand debug = 1;
  total_size += 1UL * this->_internal_debug_size();
  for (const auto& msg : this->debug_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 RequestDebug::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.RequestDebug)
  GOOGLE_DCHECK_NE(&from, this);
  const RequestDebug* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RequestDebug>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.RequestDebug)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.RequestDebug)
    MergeFrom(*source);
  }
}

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

  debug_.MergeFrom(from.debug_);
}

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

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

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

void RequestDebug::InternalSwap(RequestDebug* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  debug_.InternalSwap(&other->debug_);
}

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


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

void ResponseDebug::InitAsDefaultInstance() {
}
class ResponseDebug::_Internal {
 public:
  using HasBits = decltype(std::declval<ResponseDebug>()._has_bits_);
};

ResponseDebug::ResponseDebug()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ResponseDebug)
}
ResponseDebug::ResponseDebug(const ResponseDebug& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ResponseDebug)
}

void ResponseDebug::SharedCtor() {
}

ResponseDebug::~ResponseDebug() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ResponseDebug)
  SharedDtor();
}

void ResponseDebug::SharedDtor() {
}

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


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

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ResponseDebug::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ResponseDebug)
  return target;
}

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

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

  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 ResponseDebug::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ResponseDebug)
  GOOGLE_DCHECK_NE(&from, this);
  const ResponseDebug* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResponseDebug>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ResponseDebug)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ResponseDebug)
    MergeFrom(*source);
  }
}

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

}

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

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

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

void ResponseDebug::InternalSwap(ResponseDebug* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
}

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


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

void PlayerSetup::InitAsDefaultInstance() {
}
class PlayerSetup::_Internal {
 public:
  using HasBits = decltype(std::declval<PlayerSetup>()._has_bits_);
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_race(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_difficulty(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_player_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ai_build(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

PlayerSetup::PlayerSetup()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.PlayerSetup)
}
PlayerSetup::PlayerSetup(const PlayerSetup& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  player_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_player_name()) {
    player_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.player_name_);
  }
  ::memcpy(&race_, &from.race_,
    static_cast<size_t>(reinterpret_cast<char*>(&difficulty_) -
    reinterpret_cast<char*>(&race_)) + sizeof(difficulty_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.PlayerSetup)
}

void PlayerSetup::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PlayerSetup_s2clientprotocol_2fsc2api_2eproto.base);
  player_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  race_ = 0;
  ai_build_ = 1;
  type_ = 1;
  difficulty_ = 1;
}

PlayerSetup::~PlayerSetup() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.PlayerSetup)
  SharedDtor();
}

void PlayerSetup::SharedDtor() {
  player_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void PlayerSetup::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.PlayerSetup)
  ::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 & 0x00000001u) {
    player_name_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x0000001eu) {
    race_ = 0;
    ai_build_ = 1;
    type_ = 1;
    difficulty_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* PlayerSetup::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.PlayerType 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(::SC2APIProtocol::PlayerType_IsValid(val))) {
            _internal_set_type(static_cast<::SC2APIProtocol::PlayerType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Race race = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Race_IsValid(val))) {
            _internal_set_race(static_cast<::SC2APIProtocol::Race>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Difficulty difficulty = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Difficulty_IsValid(val))) {
            _internal_set_difficulty(static_cast<::SC2APIProtocol::Difficulty>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string player_name = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_player_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.PlayerSetup.player_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.AIBuild ai_build = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::AIBuild_IsValid(val))) {
            _internal_set_ai_build(static_cast<::SC2APIProtocol::AIBuild>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.PlayerType type = 1;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  // optional .SC2APIProtocol.Race race = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_race(), target);
  }

  // optional .SC2APIProtocol.Difficulty difficulty = 3;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_difficulty(), target);
  }

  // optional string player_name = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_player_name().data(), static_cast<int>(this->_internal_player_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.PlayerSetup.player_name");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_player_name(), target);
  }

  // optional .SC2APIProtocol.AIBuild ai_build = 5;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_ai_build(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.PlayerSetup)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string player_name = 4;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_player_name());
    }

    // optional .SC2APIProtocol.Race race = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_race());
    }

    // optional .SC2APIProtocol.AIBuild ai_build = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ai_build());
    }

    // optional .SC2APIProtocol.PlayerType type = 1;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

    // optional .SC2APIProtocol.Difficulty difficulty = 3;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_difficulty());
    }

  }
  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 PlayerSetup::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.PlayerSetup)
  GOOGLE_DCHECK_NE(&from, this);
  const PlayerSetup* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PlayerSetup>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.PlayerSetup)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.PlayerSetup)
    MergeFrom(*source);
  }
}

void PlayerSetup::MergeFrom(const PlayerSetup& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.PlayerSetup)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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) {
      _has_bits_[0] |= 0x00000001u;
      player_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.player_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      race_ = from.race_;
    }
    if (cached_has_bits & 0x00000004u) {
      ai_build_ = from.ai_build_;
    }
    if (cached_has_bits & 0x00000008u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000010u) {
      difficulty_ = from.difficulty_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void PlayerSetup::InternalSwap(PlayerSetup* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  player_name_.Swap(&other->player_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(race_, other->race_);
  swap(ai_build_, other->ai_build_);
  swap(type_, other->type_);
  swap(difficulty_, other->difficulty_);
}

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


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

void SpatialCameraSetup::InitAsDefaultInstance() {
  ::SC2APIProtocol::_SpatialCameraSetup_default_instance_._instance.get_mutable()->resolution_ = const_cast< ::SC2APIProtocol::Size2DI*>(
      ::SC2APIProtocol::Size2DI::internal_default_instance());
  ::SC2APIProtocol::_SpatialCameraSetup_default_instance_._instance.get_mutable()->minimap_resolution_ = const_cast< ::SC2APIProtocol::Size2DI*>(
      ::SC2APIProtocol::Size2DI::internal_default_instance());
}
class SpatialCameraSetup::_Internal {
 public:
  using HasBits = decltype(std::declval<SpatialCameraSetup>()._has_bits_);
  static const ::SC2APIProtocol::Size2DI& resolution(const SpatialCameraSetup* msg);
  static void set_has_resolution(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Size2DI& minimap_resolution(const SpatialCameraSetup* msg);
  static void set_has_minimap_resolution(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_width(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_crop_to_playable_area(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_allow_cheating_layers(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

const ::SC2APIProtocol::Size2DI&
SpatialCameraSetup::_Internal::resolution(const SpatialCameraSetup* msg) {
  return *msg->resolution_;
}
const ::SC2APIProtocol::Size2DI&
SpatialCameraSetup::_Internal::minimap_resolution(const SpatialCameraSetup* msg) {
  return *msg->minimap_resolution_;
}
void SpatialCameraSetup::clear_resolution() {
  if (resolution_ != nullptr) resolution_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void SpatialCameraSetup::clear_minimap_resolution() {
  if (minimap_resolution_ != nullptr) minimap_resolution_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
SpatialCameraSetup::SpatialCameraSetup()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.SpatialCameraSetup)
}
SpatialCameraSetup::SpatialCameraSetup(const SpatialCameraSetup& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_resolution()) {
    resolution_ = new ::SC2APIProtocol::Size2DI(*from.resolution_);
  } else {
    resolution_ = nullptr;
  }
  if (from._internal_has_minimap_resolution()) {
    minimap_resolution_ = new ::SC2APIProtocol::Size2DI(*from.minimap_resolution_);
  } else {
    minimap_resolution_ = nullptr;
  }
  ::memcpy(&width_, &from.width_,
    static_cast<size_t>(reinterpret_cast<char*>(&allow_cheating_layers_) -
    reinterpret_cast<char*>(&width_)) + sizeof(allow_cheating_layers_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.SpatialCameraSetup)
}

void SpatialCameraSetup::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SpatialCameraSetup_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&resolution_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&allow_cheating_layers_) -
      reinterpret_cast<char*>(&resolution_)) + sizeof(allow_cheating_layers_));
}

SpatialCameraSetup::~SpatialCameraSetup() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.SpatialCameraSetup)
  SharedDtor();
}

void SpatialCameraSetup::SharedDtor() {
  if (this != internal_default_instance()) delete resolution_;
  if (this != internal_default_instance()) delete minimap_resolution_;
}

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


void SpatialCameraSetup::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.SpatialCameraSetup)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(resolution_ != nullptr);
      resolution_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(minimap_resolution_ != nullptr);
      minimap_resolution_->Clear();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&width_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&allow_cheating_layers_) -
        reinterpret_cast<char*>(&width_)) + sizeof(allow_cheating_layers_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* SpatialCameraSetup::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional float width = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_width(&has_bits);
          width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Size2DI resolution = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_resolution(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Size2DI minimap_resolution = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_minimap_resolution(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool crop_to_playable_area = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_crop_to_playable_area(&has_bits);
          crop_to_playable_area_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool allow_cheating_layers = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_allow_cheating_layers(&has_bits);
          allow_cheating_layers_ = ::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_, 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* SpatialCameraSetup::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.SpatialCameraSetup)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float width = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_width(), target);
  }

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

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

  // optional bool crop_to_playable_area = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_crop_to_playable_area(), target);
  }

  // optional bool allow_cheating_layers = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_allow_cheating_layers(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.SpatialCameraSetup)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional .SC2APIProtocol.Size2DI resolution = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *resolution_);
    }

    // optional .SC2APIProtocol.Size2DI minimap_resolution = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *minimap_resolution_);
    }

    // optional float width = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 4;
    }

    // optional bool crop_to_playable_area = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool allow_cheating_layers = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  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 SpatialCameraSetup::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.SpatialCameraSetup)
  GOOGLE_DCHECK_NE(&from, this);
  const SpatialCameraSetup* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SpatialCameraSetup>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.SpatialCameraSetup)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.SpatialCameraSetup)
    MergeFrom(*source);
  }
}

void SpatialCameraSetup::MergeFrom(const SpatialCameraSetup& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.SpatialCameraSetup)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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_mutable_resolution()->::SC2APIProtocol::Size2DI::MergeFrom(from._internal_resolution());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_minimap_resolution()->::SC2APIProtocol::Size2DI::MergeFrom(from._internal_minimap_resolution());
    }
    if (cached_has_bits & 0x00000004u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000008u) {
      crop_to_playable_area_ = from.crop_to_playable_area_;
    }
    if (cached_has_bits & 0x00000010u) {
      allow_cheating_layers_ = from.allow_cheating_layers_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void SpatialCameraSetup::InternalSwap(SpatialCameraSetup* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(resolution_, other->resolution_);
  swap(minimap_resolution_, other->minimap_resolution_);
  swap(width_, other->width_);
  swap(crop_to_playable_area_, other->crop_to_playable_area_);
  swap(allow_cheating_layers_, other->allow_cheating_layers_);
}

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


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

void InterfaceOptions::InitAsDefaultInstance() {
  ::SC2APIProtocol::_InterfaceOptions_default_instance_._instance.get_mutable()->feature_layer_ = const_cast< ::SC2APIProtocol::SpatialCameraSetup*>(
      ::SC2APIProtocol::SpatialCameraSetup::internal_default_instance());
  ::SC2APIProtocol::_InterfaceOptions_default_instance_._instance.get_mutable()->render_ = const_cast< ::SC2APIProtocol::SpatialCameraSetup*>(
      ::SC2APIProtocol::SpatialCameraSetup::internal_default_instance());
}
class InterfaceOptions::_Internal {
 public:
  using HasBits = decltype(std::declval<InterfaceOptions>()._has_bits_);
  static void set_has_raw(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_score(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SC2APIProtocol::SpatialCameraSetup& feature_layer(const InterfaceOptions* msg);
  static void set_has_feature_layer(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::SpatialCameraSetup& render(const InterfaceOptions* msg);
  static void set_has_render(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_show_cloaked(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_show_burrowed_shadows(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_show_placeholders(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_raw_affects_selection(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_raw_crop_to_playable_area(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
};

const ::SC2APIProtocol::SpatialCameraSetup&
InterfaceOptions::_Internal::feature_layer(const InterfaceOptions* msg) {
  return *msg->feature_layer_;
}
const ::SC2APIProtocol::SpatialCameraSetup&
InterfaceOptions::_Internal::render(const InterfaceOptions* msg) {
  return *msg->render_;
}
InterfaceOptions::InterfaceOptions()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.InterfaceOptions)
}
InterfaceOptions::InterfaceOptions(const InterfaceOptions& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_feature_layer()) {
    feature_layer_ = new ::SC2APIProtocol::SpatialCameraSetup(*from.feature_layer_);
  } else {
    feature_layer_ = nullptr;
  }
  if (from._internal_has_render()) {
    render_ = new ::SC2APIProtocol::SpatialCameraSetup(*from.render_);
  } else {
    render_ = nullptr;
  }
  ::memcpy(&raw_, &from.raw_,
    static_cast<size_t>(reinterpret_cast<char*>(&raw_crop_to_playable_area_) -
    reinterpret_cast<char*>(&raw_)) + sizeof(raw_crop_to_playable_area_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.InterfaceOptions)
}

void InterfaceOptions::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_InterfaceOptions_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&feature_layer_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&raw_crop_to_playable_area_) -
      reinterpret_cast<char*>(&feature_layer_)) + sizeof(raw_crop_to_playable_area_));
}

InterfaceOptions::~InterfaceOptions() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.InterfaceOptions)
  SharedDtor();
}

void InterfaceOptions::SharedDtor() {
  if (this != internal_default_instance()) delete feature_layer_;
  if (this != internal_default_instance()) delete render_;
}

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


void InterfaceOptions::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.InterfaceOptions)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(feature_layer_ != nullptr);
      feature_layer_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(render_ != nullptr);
      render_->Clear();
    }
  }
  if (cached_has_bits & 0x000000fcu) {
    ::memset(&raw_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&raw_affects_selection_) -
        reinterpret_cast<char*>(&raw_)) + sizeof(raw_affects_selection_));
  }
  raw_crop_to_playable_area_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* InterfaceOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool raw = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_raw(&has_bits);
          raw_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool score = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_score(&has_bits);
          score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.SpatialCameraSetup feature_layer = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_feature_layer(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.SpatialCameraSetup render = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_render(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool show_cloaked = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_show_cloaked(&has_bits);
          show_cloaked_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool raw_affects_selection = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_raw_affects_selection(&has_bits);
          raw_affects_selection_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool raw_crop_to_playable_area = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_raw_crop_to_playable_area(&has_bits);
          raw_crop_to_playable_area_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool show_placeholders = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_show_placeholders(&has_bits);
          show_placeholders_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool show_burrowed_shadows = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_show_burrowed_shadows(&has_bits);
          show_burrowed_shadows_ = ::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_, 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* InterfaceOptions::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.InterfaceOptions)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool raw = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_raw(), target);
  }

  // optional bool score = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_score(), target);
  }

  // optional .SC2APIProtocol.SpatialCameraSetup feature_layer = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::feature_layer(this), target, stream);
  }

  // optional .SC2APIProtocol.SpatialCameraSetup render = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::render(this), target, stream);
  }

  // optional bool show_cloaked = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_show_cloaked(), target);
  }

  // optional bool raw_affects_selection = 6;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_raw_affects_selection(), target);
  }

  // optional bool raw_crop_to_playable_area = 7;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_raw_crop_to_playable_area(), target);
  }

  // optional bool show_placeholders = 8;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_show_placeholders(), target);
  }

  // optional bool show_burrowed_shadows = 9;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_show_burrowed_shadows(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.InterfaceOptions)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .SC2APIProtocol.SpatialCameraSetup feature_layer = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *feature_layer_);
    }

    // optional .SC2APIProtocol.SpatialCameraSetup render = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *render_);
    }

    // optional bool raw = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

    // optional bool score = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool show_cloaked = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool show_burrowed_shadows = 9;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

    // optional bool show_placeholders = 8;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 1;
    }

    // optional bool raw_affects_selection = 6;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 1;
    }

  }
  // optional bool raw_crop_to_playable_area = 7;
  if (cached_has_bits & 0x00000100u) {
    total_size += 1 + 1;
  }

  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 InterfaceOptions::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.InterfaceOptions)
  GOOGLE_DCHECK_NE(&from, this);
  const InterfaceOptions* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<InterfaceOptions>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.InterfaceOptions)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.InterfaceOptions)
    MergeFrom(*source);
  }
}

void InterfaceOptions::MergeFrom(const InterfaceOptions& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.InterfaceOptions)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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_feature_layer()->::SC2APIProtocol::SpatialCameraSetup::MergeFrom(from._internal_feature_layer());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_render()->::SC2APIProtocol::SpatialCameraSetup::MergeFrom(from._internal_render());
    }
    if (cached_has_bits & 0x00000004u) {
      raw_ = from.raw_;
    }
    if (cached_has_bits & 0x00000008u) {
      score_ = from.score_;
    }
    if (cached_has_bits & 0x00000010u) {
      show_cloaked_ = from.show_cloaked_;
    }
    if (cached_has_bits & 0x00000020u) {
      show_burrowed_shadows_ = from.show_burrowed_shadows_;
    }
    if (cached_has_bits & 0x00000040u) {
      show_placeholders_ = from.show_placeholders_;
    }
    if (cached_has_bits & 0x00000080u) {
      raw_affects_selection_ = from.raw_affects_selection_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    _internal_set_raw_crop_to_playable_area(from._internal_raw_crop_to_playable_area());
  }
}

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

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

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

void InterfaceOptions::InternalSwap(InterfaceOptions* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(feature_layer_, other->feature_layer_);
  swap(render_, other->render_);
  swap(raw_, other->raw_);
  swap(score_, other->score_);
  swap(show_cloaked_, other->show_cloaked_);
  swap(show_burrowed_shadows_, other->show_burrowed_shadows_);
  swap(show_placeholders_, other->show_placeholders_);
  swap(raw_affects_selection_, other->raw_affects_selection_);
  swap(raw_crop_to_playable_area_, other->raw_crop_to_playable_area_);
}

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


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

void PlayerInfo::InitAsDefaultInstance() {
}
class PlayerInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<PlayerInfo>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_race_requested(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_race_actual(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_difficulty(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_ai_build(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_player_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

PlayerInfo::PlayerInfo()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.PlayerInfo)
}
PlayerInfo::PlayerInfo(const PlayerInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  player_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_player_name()) {
    player_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.player_name_);
  }
  ::memcpy(&player_id_, &from.player_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&difficulty_) -
    reinterpret_cast<char*>(&player_id_)) + sizeof(difficulty_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.PlayerInfo)
}

void PlayerInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PlayerInfo_s2clientprotocol_2fsc2api_2eproto.base);
  player_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&player_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&race_actual_) -
      reinterpret_cast<char*>(&player_id_)) + sizeof(race_actual_));
  ai_build_ = 1;
  type_ = 1;
  difficulty_ = 1;
}

PlayerInfo::~PlayerInfo() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.PlayerInfo)
  SharedDtor();
}

void PlayerInfo::SharedDtor() {
  player_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void PlayerInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.PlayerInfo)
  ::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 & 0x00000001u) {
    player_name_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x0000007eu) {
    ::memset(&player_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&race_actual_) -
        reinterpret_cast<char*>(&player_id_)) + sizeof(race_actual_));
    ai_build_ = 1;
    type_ = 1;
    difficulty_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* PlayerInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.PlayerType type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::PlayerType_IsValid(val))) {
            _internal_set_type(static_cast<::SC2APIProtocol::PlayerType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Race race_requested = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Race_IsValid(val))) {
            _internal_set_race_requested(static_cast<::SC2APIProtocol::Race>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Race race_actual = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Race_IsValid(val))) {
            _internal_set_race_actual(static_cast<::SC2APIProtocol::Race>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Difficulty difficulty = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Difficulty_IsValid(val))) {
            _internal_set_difficulty(static_cast<::SC2APIProtocol::Difficulty>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string player_name = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_player_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.PlayerInfo.player_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.AIBuild ai_build = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::AIBuild_IsValid(val))) {
            _internal_set_ai_build(static_cast<::SC2APIProtocol::AIBuild>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

  // optional .SC2APIProtocol.PlayerType type = 2;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_type(), target);
  }

  // optional .SC2APIProtocol.Race race_requested = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_race_requested(), target);
  }

  // optional .SC2APIProtocol.Race race_actual = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_race_actual(), target);
  }

  // optional .SC2APIProtocol.Difficulty difficulty = 5;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_difficulty(), target);
  }

  // optional string player_name = 6;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_player_name().data(), static_cast<int>(this->_internal_player_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "SC2APIProtocol.PlayerInfo.player_name");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_player_name(), target);
  }

  // optional .SC2APIProtocol.AIBuild ai_build = 7;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      7, this->_internal_ai_build(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.PlayerInfo)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    // optional string player_name = 6;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_player_name());
    }

    // optional uint32 player_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_player_id());
    }

    // optional .SC2APIProtocol.Race race_requested = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_race_requested());
    }

    // optional .SC2APIProtocol.Race race_actual = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_race_actual());
    }

    // optional .SC2APIProtocol.AIBuild ai_build = 7;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_ai_build());
    }

    // optional .SC2APIProtocol.PlayerType type = 2;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

    // optional .SC2APIProtocol.Difficulty difficulty = 5;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_difficulty());
    }

  }
  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 PlayerInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.PlayerInfo)
  GOOGLE_DCHECK_NE(&from, this);
  const PlayerInfo* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PlayerInfo>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.PlayerInfo)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.PlayerInfo)
    MergeFrom(*source);
  }
}

void PlayerInfo::MergeFrom(const PlayerInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.PlayerInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      player_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.player_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      player_id_ = from.player_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      race_requested_ = from.race_requested_;
    }
    if (cached_has_bits & 0x00000008u) {
      race_actual_ = from.race_actual_;
    }
    if (cached_has_bits & 0x00000010u) {
      ai_build_ = from.ai_build_;
    }
    if (cached_has_bits & 0x00000020u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000040u) {
      difficulty_ = from.difficulty_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void PlayerInfo::InternalSwap(PlayerInfo* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  player_name_.Swap(&other->player_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(player_id_, other->player_id_);
  swap(race_requested_, other->race_requested_);
  swap(race_actual_, other->race_actual_);
  swap(ai_build_, other->ai_build_);
  swap(type_, other->type_);
  swap(difficulty_, other->difficulty_);
}

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


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

void PlayerCommon::InitAsDefaultInstance() {
}
class PlayerCommon::_Internal {
 public:
  using HasBits = decltype(std::declval<PlayerCommon>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_minerals(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_vespene(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_food_cap(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_food_used(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_food_army(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_food_workers(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_idle_worker_count(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_army_count(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_warp_gate_count(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_larva_count(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
};

PlayerCommon::PlayerCommon()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.PlayerCommon)
}
PlayerCommon::PlayerCommon(const PlayerCommon& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&player_id_, &from.player_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&larva_count_) -
    reinterpret_cast<char*>(&player_id_)) + sizeof(larva_count_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.PlayerCommon)
}

void PlayerCommon::SharedCtor() {
  ::memset(&player_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&larva_count_) -
      reinterpret_cast<char*>(&player_id_)) + sizeof(larva_count_));
}

PlayerCommon::~PlayerCommon() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.PlayerCommon)
  SharedDtor();
}

void PlayerCommon::SharedDtor() {
}

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


void PlayerCommon::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.PlayerCommon)
  ::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) {
    ::memset(&player_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&idle_worker_count_) -
        reinterpret_cast<char*>(&player_id_)) + sizeof(idle_worker_count_));
  }
  if (cached_has_bits & 0x00000700u) {
    ::memset(&army_count_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&larva_count_) -
        reinterpret_cast<char*>(&army_count_)) + sizeof(larva_count_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* PlayerCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 minerals = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_minerals(&has_bits);
          minerals_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 vespene = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_vespene(&has_bits);
          vespene_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 food_cap = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_food_cap(&has_bits);
          food_cap_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 food_used = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_food_used(&has_bits);
          food_used_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 food_army = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_food_army(&has_bits);
          food_army_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 food_workers = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_food_workers(&has_bits);
          food_workers_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 idle_worker_count = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_idle_worker_count(&has_bits);
          idle_worker_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 army_count = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_army_count(&has_bits);
          army_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 warp_gate_count = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_warp_gate_count(&has_bits);
          warp_gate_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 larva_count = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_larva_count(&has_bits);
          larva_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

  // optional uint32 minerals = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_minerals(), target);
  }

  // optional uint32 vespene = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_vespene(), target);
  }

  // optional uint32 food_cap = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_food_cap(), target);
  }

  // optional uint32 food_used = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_food_used(), target);
  }

  // optional uint32 food_army = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_food_army(), target);
  }

  // optional uint32 food_workers = 7;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_food_workers(), target);
  }

  // optional uint32 idle_worker_count = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_idle_worker_count(), target);
  }

  // optional uint32 army_count = 9;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_army_count(), target);
  }

  // optional uint32 warp_gate_count = 10;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_warp_gate_count(), target);
  }

  // optional uint32 larva_count = 11;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(11, this->_internal_larva_count(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.PlayerCommon)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional uint32 player_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_player_id());
    }

    // optional uint32 minerals = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_minerals());
    }

    // optional uint32 vespene = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_vespene());
    }

    // optional uint32 food_cap = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_food_cap());
    }

    // optional uint32 food_used = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_food_used());
    }

    // optional uint32 food_army = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_food_army());
    }

    // optional uint32 food_workers = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_food_workers());
    }

    // optional uint32 idle_worker_count = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_idle_worker_count());
    }

  }
  if (cached_has_bits & 0x00000700u) {
    // optional uint32 army_count = 9;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_army_count());
    }

    // optional uint32 warp_gate_count = 10;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_warp_gate_count());
    }

    // optional uint32 larva_count = 11;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_larva_count());
    }

  }
  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 PlayerCommon::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.PlayerCommon)
  GOOGLE_DCHECK_NE(&from, this);
  const PlayerCommon* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PlayerCommon>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.PlayerCommon)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.PlayerCommon)
    MergeFrom(*source);
  }
}

void PlayerCommon::MergeFrom(const PlayerCommon& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.PlayerCommon)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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) {
      player_id_ = from.player_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      minerals_ = from.minerals_;
    }
    if (cached_has_bits & 0x00000004u) {
      vespene_ = from.vespene_;
    }
    if (cached_has_bits & 0x00000008u) {
      food_cap_ = from.food_cap_;
    }
    if (cached_has_bits & 0x00000010u) {
      food_used_ = from.food_used_;
    }
    if (cached_has_bits & 0x00000020u) {
      food_army_ = from.food_army_;
    }
    if (cached_has_bits & 0x00000040u) {
      food_workers_ = from.food_workers_;
    }
    if (cached_has_bits & 0x00000080u) {
      idle_worker_count_ = from.idle_worker_count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000700u) {
    if (cached_has_bits & 0x00000100u) {
      army_count_ = from.army_count_;
    }
    if (cached_has_bits & 0x00000200u) {
      warp_gate_count_ = from.warp_gate_count_;
    }
    if (cached_has_bits & 0x00000400u) {
      larva_count_ = from.larva_count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void PlayerCommon::InternalSwap(PlayerCommon* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(player_id_, other->player_id_);
  swap(minerals_, other->minerals_);
  swap(vespene_, other->vespene_);
  swap(food_cap_, other->food_cap_);
  swap(food_used_, other->food_used_);
  swap(food_army_, other->food_army_);
  swap(food_workers_, other->food_workers_);
  swap(idle_worker_count_, other->idle_worker_count_);
  swap(army_count_, other->army_count_);
  swap(warp_gate_count_, other->warp_gate_count_);
  swap(larva_count_, other->larva_count_);
}

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


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

void Observation::InitAsDefaultInstance() {
  ::SC2APIProtocol::_Observation_default_instance_._instance.get_mutable()->player_common_ = const_cast< ::SC2APIProtocol::PlayerCommon*>(
      ::SC2APIProtocol::PlayerCommon::internal_default_instance());
  ::SC2APIProtocol::_Observation_default_instance_._instance.get_mutable()->score_ = const_cast< ::SC2APIProtocol::Score*>(
      ::SC2APIProtocol::Score::internal_default_instance());
  ::SC2APIProtocol::_Observation_default_instance_._instance.get_mutable()->raw_data_ = const_cast< ::SC2APIProtocol::ObservationRaw*>(
      ::SC2APIProtocol::ObservationRaw::internal_default_instance());
  ::SC2APIProtocol::_Observation_default_instance_._instance.get_mutable()->feature_layer_data_ = const_cast< ::SC2APIProtocol::ObservationFeatureLayer*>(
      ::SC2APIProtocol::ObservationFeatureLayer::internal_default_instance());
  ::SC2APIProtocol::_Observation_default_instance_._instance.get_mutable()->render_data_ = const_cast< ::SC2APIProtocol::ObservationRender*>(
      ::SC2APIProtocol::ObservationRender::internal_default_instance());
  ::SC2APIProtocol::_Observation_default_instance_._instance.get_mutable()->ui_data_ = const_cast< ::SC2APIProtocol::ObservationUI*>(
      ::SC2APIProtocol::ObservationUI::internal_default_instance());
}
class Observation::_Internal {
 public:
  using HasBits = decltype(std::declval<Observation>()._has_bits_);
  static void set_has_game_loop(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::SC2APIProtocol::PlayerCommon& player_common(const Observation* msg);
  static void set_has_player_common(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Score& score(const Observation* msg);
  static void set_has_score(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SC2APIProtocol::ObservationRaw& raw_data(const Observation* msg);
  static void set_has_raw_data(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::ObservationFeatureLayer& feature_layer_data(const Observation* msg);
  static void set_has_feature_layer_data(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SC2APIProtocol::ObservationRender& render_data(const Observation* msg);
  static void set_has_render_data(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::SC2APIProtocol::ObservationUI& ui_data(const Observation* msg);
  static void set_has_ui_data(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::SC2APIProtocol::PlayerCommon&
Observation::_Internal::player_common(const Observation* msg) {
  return *msg->player_common_;
}
const ::SC2APIProtocol::Score&
Observation::_Internal::score(const Observation* msg) {
  return *msg->score_;
}
const ::SC2APIProtocol::ObservationRaw&
Observation::_Internal::raw_data(const Observation* msg) {
  return *msg->raw_data_;
}
const ::SC2APIProtocol::ObservationFeatureLayer&
Observation::_Internal::feature_layer_data(const Observation* msg) {
  return *msg->feature_layer_data_;
}
const ::SC2APIProtocol::ObservationRender&
Observation::_Internal::render_data(const Observation* msg) {
  return *msg->render_data_;
}
const ::SC2APIProtocol::ObservationUI&
Observation::_Internal::ui_data(const Observation* msg) {
  return *msg->ui_data_;
}
void Observation::clear_abilities() {
  abilities_.Clear();
}
void Observation::clear_score() {
  if (score_ != nullptr) score_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
void Observation::clear_raw_data() {
  if (raw_data_ != nullptr) raw_data_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
void Observation::clear_feature_layer_data() {
  if (feature_layer_data_ != nullptr) feature_layer_data_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
void Observation::clear_render_data() {
  if (render_data_ != nullptr) render_data_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
void Observation::clear_ui_data() {
  if (ui_data_ != nullptr) ui_data_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
Observation::Observation()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.Observation)
}
Observation::Observation(const Observation& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      abilities_(from.abilities_),
      alerts_(from.alerts_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_player_common()) {
    player_common_ = new ::SC2APIProtocol::PlayerCommon(*from.player_common_);
  } else {
    player_common_ = nullptr;
  }
  if (from._internal_has_score()) {
    score_ = new ::SC2APIProtocol::Score(*from.score_);
  } else {
    score_ = nullptr;
  }
  if (from._internal_has_raw_data()) {
    raw_data_ = new ::SC2APIProtocol::ObservationRaw(*from.raw_data_);
  } else {
    raw_data_ = nullptr;
  }
  if (from._internal_has_feature_layer_data()) {
    feature_layer_data_ = new ::SC2APIProtocol::ObservationFeatureLayer(*from.feature_layer_data_);
  } else {
    feature_layer_data_ = nullptr;
  }
  if (from._internal_has_render_data()) {
    render_data_ = new ::SC2APIProtocol::ObservationRender(*from.render_data_);
  } else {
    render_data_ = nullptr;
  }
  if (from._internal_has_ui_data()) {
    ui_data_ = new ::SC2APIProtocol::ObservationUI(*from.ui_data_);
  } else {
    ui_data_ = nullptr;
  }
  game_loop_ = from.game_loop_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.Observation)
}

void Observation::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Observation_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&player_common_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&game_loop_) -
      reinterpret_cast<char*>(&player_common_)) + sizeof(game_loop_));
}

Observation::~Observation() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.Observation)
  SharedDtor();
}

void Observation::SharedDtor() {
  if (this != internal_default_instance()) delete player_common_;
  if (this != internal_default_instance()) delete score_;
  if (this != internal_default_instance()) delete raw_data_;
  if (this != internal_default_instance()) delete feature_layer_data_;
  if (this != internal_default_instance()) delete render_data_;
  if (this != internal_default_instance()) delete ui_data_;
}

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


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

  abilities_.Clear();
  alerts_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(player_common_ != nullptr);
      player_common_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(score_ != nullptr);
      score_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(raw_data_ != nullptr);
      raw_data_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(feature_layer_data_ != nullptr);
      feature_layer_data_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(render_data_ != nullptr);
      render_data_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(ui_data_ != nullptr);
      ui_data_->Clear();
    }
  }
  game_loop_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Observation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.PlayerCommon player_common = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_common(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.AvailableAbility abilities = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_abilities(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Score score = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_score(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ObservationRaw raw_data = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_raw_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ObservationFeatureLayer feature_layer_data = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_feature_layer_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ObservationRender render_data = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_render_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ObservationUI ui_data = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_ui_data(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 game_loop = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_game_loop(&has_bits);
          game_loop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.Alert alerts = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Alert_IsValid(val))) {
              _internal_add_alerts(static_cast<::SC2APIProtocol::Alert>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<80>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_alerts(), ptr, ctx, ::SC2APIProtocol::Alert_IsValid, &_internal_metadata_, 10);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.PlayerCommon player_common = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::player_common(this), target, stream);
  }

  // repeated .SC2APIProtocol.AvailableAbility abilities = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_abilities_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_abilities(i), target, stream);
  }

  // optional .SC2APIProtocol.Score score = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::score(this), target, stream);
  }

  // optional .SC2APIProtocol.ObservationRaw raw_data = 5;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::raw_data(this), target, stream);
  }

  // optional .SC2APIProtocol.ObservationFeatureLayer feature_layer_data = 6;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::feature_layer_data(this), target, stream);
  }

  // optional .SC2APIProtocol.ObservationRender render_data = 7;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::render_data(this), target, stream);
  }

  // optional .SC2APIProtocol.ObservationUI ui_data = 8;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::ui_data(this), target, stream);
  }

  // optional uint32 game_loop = 9;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_game_loop(), target);
  }

  // repeated .SC2APIProtocol.Alert alerts = 10;
  for (int i = 0, n = this->_internal_alerts_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        10, this->_internal_alerts(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.Observation)
  return target;
}

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

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

  // repeated .SC2APIProtocol.AvailableAbility abilities = 3;
  total_size += 1UL * this->_internal_abilities_size();
  for (const auto& msg : this->abilities_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.Alert alerts = 10;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_alerts_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_alerts(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    // optional .SC2APIProtocol.PlayerCommon player_common = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_common_);
    }

    // optional .SC2APIProtocol.Score score = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *score_);
    }

    // optional .SC2APIProtocol.ObservationRaw raw_data = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *raw_data_);
    }

    // optional .SC2APIProtocol.ObservationFeatureLayer feature_layer_data = 6;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *feature_layer_data_);
    }

    // optional .SC2APIProtocol.ObservationRender render_data = 7;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *render_data_);
    }

    // optional .SC2APIProtocol.ObservationUI ui_data = 8;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *ui_data_);
    }

    // optional uint32 game_loop = 9;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_game_loop());
    }

  }
  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 Observation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.Observation)
  GOOGLE_DCHECK_NE(&from, this);
  const Observation* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Observation>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.Observation)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.Observation)
    MergeFrom(*source);
  }
}

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

  abilities_.MergeFrom(from.abilities_);
  alerts_.MergeFrom(from.alerts_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_player_common()->::SC2APIProtocol::PlayerCommon::MergeFrom(from._internal_player_common());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_score()->::SC2APIProtocol::Score::MergeFrom(from._internal_score());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_raw_data()->::SC2APIProtocol::ObservationRaw::MergeFrom(from._internal_raw_data());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_feature_layer_data()->::SC2APIProtocol::ObservationFeatureLayer::MergeFrom(from._internal_feature_layer_data());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_render_data()->::SC2APIProtocol::ObservationRender::MergeFrom(from._internal_render_data());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_mutable_ui_data()->::SC2APIProtocol::ObservationUI::MergeFrom(from._internal_ui_data());
    }
    if (cached_has_bits & 0x00000040u) {
      game_loop_ = from.game_loop_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void Observation::InternalSwap(Observation* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  abilities_.InternalSwap(&other->abilities_);
  alerts_.InternalSwap(&other->alerts_);
  swap(player_common_, other->player_common_);
  swap(score_, other->score_);
  swap(raw_data_, other->raw_data_);
  swap(feature_layer_data_, other->feature_layer_data_);
  swap(render_data_, other->render_data_);
  swap(ui_data_, other->ui_data_);
  swap(game_loop_, other->game_loop_);
}

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


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

void Action::InitAsDefaultInstance() {
  ::SC2APIProtocol::_Action_default_instance_._instance.get_mutable()->action_raw_ = const_cast< ::SC2APIProtocol::ActionRaw*>(
      ::SC2APIProtocol::ActionRaw::internal_default_instance());
  ::SC2APIProtocol::_Action_default_instance_._instance.get_mutable()->action_feature_layer_ = const_cast< ::SC2APIProtocol::ActionSpatial*>(
      ::SC2APIProtocol::ActionSpatial::internal_default_instance());
  ::SC2APIProtocol::_Action_default_instance_._instance.get_mutable()->action_render_ = const_cast< ::SC2APIProtocol::ActionSpatial*>(
      ::SC2APIProtocol::ActionSpatial::internal_default_instance());
  ::SC2APIProtocol::_Action_default_instance_._instance.get_mutable()->action_ui_ = const_cast< ::SC2APIProtocol::ActionUI*>(
      ::SC2APIProtocol::ActionUI::internal_default_instance());
  ::SC2APIProtocol::_Action_default_instance_._instance.get_mutable()->action_chat_ = const_cast< ::SC2APIProtocol::ActionChat*>(
      ::SC2APIProtocol::ActionChat::internal_default_instance());
}
class Action::_Internal {
 public:
  using HasBits = decltype(std::declval<Action>()._has_bits_);
  static const ::SC2APIProtocol::ActionRaw& action_raw(const Action* msg);
  static void set_has_action_raw(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::ActionSpatial& action_feature_layer(const Action* msg);
  static void set_has_action_feature_layer(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SC2APIProtocol::ActionSpatial& action_render(const Action* msg);
  static void set_has_action_render(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::ActionUI& action_ui(const Action* msg);
  static void set_has_action_ui(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SC2APIProtocol::ActionChat& action_chat(const Action* msg);
  static void set_has_action_chat(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_game_loop(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::SC2APIProtocol::ActionRaw&
Action::_Internal::action_raw(const Action* msg) {
  return *msg->action_raw_;
}
const ::SC2APIProtocol::ActionSpatial&
Action::_Internal::action_feature_layer(const Action* msg) {
  return *msg->action_feature_layer_;
}
const ::SC2APIProtocol::ActionSpatial&
Action::_Internal::action_render(const Action* msg) {
  return *msg->action_render_;
}
const ::SC2APIProtocol::ActionUI&
Action::_Internal::action_ui(const Action* msg) {
  return *msg->action_ui_;
}
const ::SC2APIProtocol::ActionChat&
Action::_Internal::action_chat(const Action* msg) {
  return *msg->action_chat_;
}
void Action::clear_action_raw() {
  if (action_raw_ != nullptr) action_raw_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void Action::clear_action_feature_layer() {
  if (action_feature_layer_ != nullptr) action_feature_layer_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
void Action::clear_action_render() {
  if (action_render_ != nullptr) action_render_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
void Action::clear_action_ui() {
  if (action_ui_ != nullptr) action_ui_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
Action::Action()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.Action)
}
Action::Action(const Action& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_action_raw()) {
    action_raw_ = new ::SC2APIProtocol::ActionRaw(*from.action_raw_);
  } else {
    action_raw_ = nullptr;
  }
  if (from._internal_has_action_feature_layer()) {
    action_feature_layer_ = new ::SC2APIProtocol::ActionSpatial(*from.action_feature_layer_);
  } else {
    action_feature_layer_ = nullptr;
  }
  if (from._internal_has_action_render()) {
    action_render_ = new ::SC2APIProtocol::ActionSpatial(*from.action_render_);
  } else {
    action_render_ = nullptr;
  }
  if (from._internal_has_action_ui()) {
    action_ui_ = new ::SC2APIProtocol::ActionUI(*from.action_ui_);
  } else {
    action_ui_ = nullptr;
  }
  if (from._internal_has_action_chat()) {
    action_chat_ = new ::SC2APIProtocol::ActionChat(*from.action_chat_);
  } else {
    action_chat_ = nullptr;
  }
  game_loop_ = from.game_loop_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.Action)
}

void Action::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Action_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&action_raw_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&game_loop_) -
      reinterpret_cast<char*>(&action_raw_)) + sizeof(game_loop_));
}

Action::~Action() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.Action)
  SharedDtor();
}

void Action::SharedDtor() {
  if (this != internal_default_instance()) delete action_raw_;
  if (this != internal_default_instance()) delete action_feature_layer_;
  if (this != internal_default_instance()) delete action_render_;
  if (this != internal_default_instance()) delete action_ui_;
  if (this != internal_default_instance()) delete action_chat_;
}

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


void Action::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.Action)
  ::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 & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(action_raw_ != nullptr);
      action_raw_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(action_feature_layer_ != nullptr);
      action_feature_layer_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(action_render_ != nullptr);
      action_render_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(action_ui_ != nullptr);
      action_ui_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(action_chat_ != nullptr);
      action_chat_->Clear();
    }
  }
  game_loop_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Action::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ActionRaw action_raw = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_action_raw(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionSpatial action_feature_layer = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_action_feature_layer(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionSpatial action_render = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_action_render(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionUI action_ui = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_action_ui(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionChat action_chat = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_action_chat(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 game_loop = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_game_loop(&has_bits);
          game_loop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ActionRaw action_raw = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::action_raw(this), target, stream);
  }

  // optional .SC2APIProtocol.ActionSpatial action_feature_layer = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::action_feature_layer(this), target, stream);
  }

  // optional .SC2APIProtocol.ActionSpatial action_render = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::action_render(this), target, stream);
  }

  // optional .SC2APIProtocol.ActionUI action_ui = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::action_ui(this), target, stream);
  }

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

  // optional uint32 game_loop = 7;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_game_loop(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.Action)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional .SC2APIProtocol.ActionRaw action_raw = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_raw_);
    }

    // optional .SC2APIProtocol.ActionSpatial action_feature_layer = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_feature_layer_);
    }

    // optional .SC2APIProtocol.ActionSpatial action_render = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_render_);
    }

    // optional .SC2APIProtocol.ActionUI action_ui = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_ui_);
    }

    // optional .SC2APIProtocol.ActionChat action_chat = 6;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_chat_);
    }

    // optional uint32 game_loop = 7;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_game_loop());
    }

  }
  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 Action::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.Action)
  GOOGLE_DCHECK_NE(&from, this);
  const Action* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Action>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.Action)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.Action)
    MergeFrom(*source);
  }
}

void Action::MergeFrom(const Action& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.Action)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_action_raw()->::SC2APIProtocol::ActionRaw::MergeFrom(from._internal_action_raw());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_action_feature_layer()->::SC2APIProtocol::ActionSpatial::MergeFrom(from._internal_action_feature_layer());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_action_render()->::SC2APIProtocol::ActionSpatial::MergeFrom(from._internal_action_render());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_action_ui()->::SC2APIProtocol::ActionUI::MergeFrom(from._internal_action_ui());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_action_chat()->::SC2APIProtocol::ActionChat::MergeFrom(from._internal_action_chat());
    }
    if (cached_has_bits & 0x00000020u) {
      game_loop_ = from.game_loop_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void Action::InternalSwap(Action* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(action_raw_, other->action_raw_);
  swap(action_feature_layer_, other->action_feature_layer_);
  swap(action_render_, other->action_render_);
  swap(action_ui_, other->action_ui_);
  swap(action_chat_, other->action_chat_);
  swap(game_loop_, other->game_loop_);
}

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


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

void ActionChat::InitAsDefaultInstance() {
}
class ActionChat::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionChat>()._has_bits_);
  static void set_has_channel(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_message(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ActionChat::ActionChat()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionChat)
}
ActionChat::ActionChat(const ActionChat& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_message()) {
    message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
  }
  channel_ = from.channel_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionChat)
}

void ActionChat::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionChat_s2clientprotocol_2fsc2api_2eproto.base);
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  channel_ = 1;
}

ActionChat::~ActionChat() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ActionChat)
  SharedDtor();
}

void ActionChat::SharedDtor() {
  message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void ActionChat::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ActionChat)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      message_.ClearNonDefaultToEmptyNoArena();
    }
    channel_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionChat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ActionChat.Channel channel = 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(::SC2APIProtocol::ActionChat_Channel_IsValid(val))) {
            _internal_set_channel(static_cast<::SC2APIProtocol::ActionChat_Channel>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional string message = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_message();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.ActionChat.message");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.ActionChat.Channel channel = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_channel(), target);
  }

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

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ActionChat)
  return target;
}

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

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

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

    // optional .SC2APIProtocol.ActionChat.Channel channel = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_channel());
    }

  }
  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 ActionChat::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionChat)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionChat* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionChat>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionChat)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionChat)
    MergeFrom(*source);
  }
}

void ActionChat::MergeFrom(const ActionChat& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ActionChat)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
    if (cached_has_bits & 0x00000002u) {
      channel_ = from.channel_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ActionChat::InternalSwap(ActionChat* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(channel_, other->channel_);
}

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


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

void ActionError::InitAsDefaultInstance() {
}
class ActionError::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionError>()._has_bits_);
  static void set_has_unit_tag(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ability_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_result(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

ActionError::ActionError()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionError)
}
ActionError::ActionError(const ActionError& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&unit_tag_, &from.unit_tag_,
    static_cast<size_t>(reinterpret_cast<char*>(&result_) -
    reinterpret_cast<char*>(&unit_tag_)) + sizeof(result_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionError)
}

void ActionError::SharedCtor() {
  ::memset(&unit_tag_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&ability_id_) -
      reinterpret_cast<char*>(&unit_tag_)) + sizeof(ability_id_));
  result_ = 1;
}

ActionError::~ActionError() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ActionError)
  SharedDtor();
}

void ActionError::SharedDtor() {
}

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


void ActionError::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ActionError)
  ::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) {
    ::memset(&unit_tag_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ability_id_) -
        reinterpret_cast<char*>(&unit_tag_)) + sizeof(ability_id_));
    result_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionError::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint64 unit_tag = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_unit_tag(&has_bits);
          unit_tag_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 ability_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_ability_id(&has_bits);
          ability_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionResult result = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::ActionResult_IsValid(val))) {
            _internal_set_result(static_cast<::SC2APIProtocol::ActionResult>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint64 unit_tag = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_unit_tag(), target);
  }

  // optional uint64 ability_id = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ability_id(), target);
  }

  // optional .SC2APIProtocol.ActionResult result = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_result(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ActionError)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional uint64 unit_tag = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_unit_tag());
    }

    // optional uint64 ability_id = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_ability_id());
    }

    // optional .SC2APIProtocol.ActionResult result = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_result());
    }

  }
  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 ActionError::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionError)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionError* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionError>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionError)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionError)
    MergeFrom(*source);
  }
}

void ActionError::MergeFrom(const ActionError& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ActionError)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      unit_tag_ = from.unit_tag_;
    }
    if (cached_has_bits & 0x00000002u) {
      ability_id_ = from.ability_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      result_ = from.result_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ActionError::InternalSwap(ActionError* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(unit_tag_, other->unit_tag_);
  swap(ability_id_, other->ability_id_);
  swap(result_, other->result_);
}

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


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

void ObserverAction::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ObserverAction_default_instance_.player_perspective_ = const_cast< ::SC2APIProtocol::ActionObserverPlayerPerspective*>(
      ::SC2APIProtocol::ActionObserverPlayerPerspective::internal_default_instance());
  ::SC2APIProtocol::_ObserverAction_default_instance_.camera_move_ = const_cast< ::SC2APIProtocol::ActionObserverCameraMove*>(
      ::SC2APIProtocol::ActionObserverCameraMove::internal_default_instance());
  ::SC2APIProtocol::_ObserverAction_default_instance_.camera_follow_player_ = const_cast< ::SC2APIProtocol::ActionObserverCameraFollowPlayer*>(
      ::SC2APIProtocol::ActionObserverCameraFollowPlayer::internal_default_instance());
  ::SC2APIProtocol::_ObserverAction_default_instance_.camera_follow_units_ = const_cast< ::SC2APIProtocol::ActionObserverCameraFollowUnits*>(
      ::SC2APIProtocol::ActionObserverCameraFollowUnits::internal_default_instance());
}
class ObserverAction::_Internal {
 public:
  using HasBits = decltype(std::declval<ObserverAction>()._has_bits_);
  static const ::SC2APIProtocol::ActionObserverPlayerPerspective& player_perspective(const ObserverAction* msg);
  static const ::SC2APIProtocol::ActionObserverCameraMove& camera_move(const ObserverAction* msg);
  static const ::SC2APIProtocol::ActionObserverCameraFollowPlayer& camera_follow_player(const ObserverAction* msg);
  static const ::SC2APIProtocol::ActionObserverCameraFollowUnits& camera_follow_units(const ObserverAction* msg);
};

const ::SC2APIProtocol::ActionObserverPlayerPerspective&
ObserverAction::_Internal::player_perspective(const ObserverAction* msg) {
  return *msg->action_.player_perspective_;
}
const ::SC2APIProtocol::ActionObserverCameraMove&
ObserverAction::_Internal::camera_move(const ObserverAction* msg) {
  return *msg->action_.camera_move_;
}
const ::SC2APIProtocol::ActionObserverCameraFollowPlayer&
ObserverAction::_Internal::camera_follow_player(const ObserverAction* msg) {
  return *msg->action_.camera_follow_player_;
}
const ::SC2APIProtocol::ActionObserverCameraFollowUnits&
ObserverAction::_Internal::camera_follow_units(const ObserverAction* msg) {
  return *msg->action_.camera_follow_units_;
}
void ObserverAction::set_allocated_player_perspective(::SC2APIProtocol::ActionObserverPlayerPerspective* player_perspective) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (player_perspective) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      player_perspective = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, player_perspective, submessage_arena);
    }
    set_has_player_perspective();
    action_.player_perspective_ = player_perspective;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ObserverAction.player_perspective)
}
void ObserverAction::set_allocated_camera_move(::SC2APIProtocol::ActionObserverCameraMove* camera_move) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (camera_move) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      camera_move = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, camera_move, submessage_arena);
    }
    set_has_camera_move();
    action_.camera_move_ = camera_move;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ObserverAction.camera_move)
}
void ObserverAction::set_allocated_camera_follow_player(::SC2APIProtocol::ActionObserverCameraFollowPlayer* camera_follow_player) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (camera_follow_player) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      camera_follow_player = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, camera_follow_player, submessage_arena);
    }
    set_has_camera_follow_player();
    action_.camera_follow_player_ = camera_follow_player;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ObserverAction.camera_follow_player)
}
void ObserverAction::set_allocated_camera_follow_units(::SC2APIProtocol::ActionObserverCameraFollowUnits* camera_follow_units) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (camera_follow_units) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      camera_follow_units = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, camera_follow_units, submessage_arena);
    }
    set_has_camera_follow_units();
    action_.camera_follow_units_ = camera_follow_units;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ObserverAction.camera_follow_units)
}
ObserverAction::ObserverAction()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ObserverAction)
}
ObserverAction::ObserverAction(const ObserverAction& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_action();
  switch (from.action_case()) {
    case kPlayerPerspective: {
      _internal_mutable_player_perspective()->::SC2APIProtocol::ActionObserverPlayerPerspective::MergeFrom(from._internal_player_perspective());
      break;
    }
    case kCameraMove: {
      _internal_mutable_camera_move()->::SC2APIProtocol::ActionObserverCameraMove::MergeFrom(from._internal_camera_move());
      break;
    }
    case kCameraFollowPlayer: {
      _internal_mutable_camera_follow_player()->::SC2APIProtocol::ActionObserverCameraFollowPlayer::MergeFrom(from._internal_camera_follow_player());
      break;
    }
    case kCameraFollowUnits: {
      _internal_mutable_camera_follow_units()->::SC2APIProtocol::ActionObserverCameraFollowUnits::MergeFrom(from._internal_camera_follow_units());
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ObserverAction)
}

void ObserverAction::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ObserverAction_s2clientprotocol_2fsc2api_2eproto.base);
  clear_has_action();
}

ObserverAction::~ObserverAction() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ObserverAction)
  SharedDtor();
}

void ObserverAction::SharedDtor() {
  if (has_action()) {
    clear_action();
  }
}

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


void ObserverAction::clear_action() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.ObserverAction)
  switch (action_case()) {
    case kPlayerPerspective: {
      delete action_.player_perspective_;
      break;
    }
    case kCameraMove: {
      delete action_.camera_move_;
      break;
    }
    case kCameraFollowPlayer: {
      delete action_.camera_follow_player_;
      break;
    }
    case kCameraFollowUnits: {
      delete action_.camera_follow_units_;
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ACTION_NOT_SET;
}


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

  clear_action();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ObserverAction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.ActionObserverPlayerPerspective player_perspective = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_perspective(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionObserverCameraMove camera_move = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_camera_move(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionObserverCameraFollowPlayer camera_follow_player = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_camera_follow_player(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionObserverCameraFollowUnits camera_follow_units = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_camera_follow_units(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  switch (action_case()) {
    case kPlayerPerspective: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::player_perspective(this), target, stream);
      break;
    }
    case kCameraMove: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::camera_move(this), target, stream);
      break;
    }
    case kCameraFollowPlayer: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::camera_follow_player(this), target, stream);
      break;
    }
    case kCameraFollowUnits: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::camera_follow_units(this), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ObserverAction)
  return target;
}

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

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

  switch (action_case()) {
    // optional .SC2APIProtocol.ActionObserverPlayerPerspective player_perspective = 1;
    case kPlayerPerspective: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.player_perspective_);
      break;
    }
    // optional .SC2APIProtocol.ActionObserverCameraMove camera_move = 2;
    case kCameraMove: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.camera_move_);
      break;
    }
    // optional .SC2APIProtocol.ActionObserverCameraFollowPlayer camera_follow_player = 3;
    case kCameraFollowPlayer: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.camera_follow_player_);
      break;
    }
    // optional .SC2APIProtocol.ActionObserverCameraFollowUnits camera_follow_units = 4;
    case kCameraFollowUnits: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.camera_follow_units_);
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  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 ObserverAction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ObserverAction)
  GOOGLE_DCHECK_NE(&from, this);
  const ObserverAction* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ObserverAction>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ObserverAction)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ObserverAction)
    MergeFrom(*source);
  }
}

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

  switch (from.action_case()) {
    case kPlayerPerspective: {
      _internal_mutable_player_perspective()->::SC2APIProtocol::ActionObserverPlayerPerspective::MergeFrom(from._internal_player_perspective());
      break;
    }
    case kCameraMove: {
      _internal_mutable_camera_move()->::SC2APIProtocol::ActionObserverCameraMove::MergeFrom(from._internal_camera_move());
      break;
    }
    case kCameraFollowPlayer: {
      _internal_mutable_camera_follow_player()->::SC2APIProtocol::ActionObserverCameraFollowPlayer::MergeFrom(from._internal_camera_follow_player());
      break;
    }
    case kCameraFollowUnits: {
      _internal_mutable_camera_follow_units()->::SC2APIProtocol::ActionObserverCameraFollowUnits::MergeFrom(from._internal_camera_follow_units());
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
}

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

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

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

void ObserverAction::InternalSwap(ObserverAction* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(action_, other->action_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void ActionObserverPlayerPerspective::InitAsDefaultInstance() {
}
class ActionObserverPlayerPerspective::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionObserverPlayerPerspective>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ActionObserverPlayerPerspective::ActionObserverPlayerPerspective()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionObserverPlayerPerspective)
}
ActionObserverPlayerPerspective::ActionObserverPlayerPerspective(const ActionObserverPlayerPerspective& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  player_id_ = from.player_id_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionObserverPlayerPerspective)
}

void ActionObserverPlayerPerspective::SharedCtor() {
  player_id_ = 0u;
}

ActionObserverPlayerPerspective::~ActionObserverPlayerPerspective() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ActionObserverPlayerPerspective)
  SharedDtor();
}

void ActionObserverPlayerPerspective::SharedDtor() {
}

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


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

  player_id_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionObserverPlayerPerspective::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ActionObserverPlayerPerspective)
  return target;
}

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

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

  // optional uint32 player_id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_player_id());
  }

  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 ActionObserverPlayerPerspective::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionObserverPlayerPerspective)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionObserverPlayerPerspective* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionObserverPlayerPerspective>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionObserverPlayerPerspective)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionObserverPlayerPerspective)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_player_id()) {
    _internal_set_player_id(from._internal_player_id());
  }
}

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

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

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

void ActionObserverPlayerPerspective::InternalSwap(ActionObserverPlayerPerspective* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(player_id_, other->player_id_);
}

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


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

void ActionObserverCameraMove::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ActionObserverCameraMove_default_instance_._instance.get_mutable()->world_pos_ = const_cast< ::SC2APIProtocol::Point2D*>(
      ::SC2APIProtocol::Point2D::internal_default_instance());
}
class ActionObserverCameraMove::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionObserverCameraMove>()._has_bits_);
  static const ::SC2APIProtocol::Point2D& world_pos(const ActionObserverCameraMove* msg);
  static void set_has_world_pos(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_distance(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::Point2D&
ActionObserverCameraMove::_Internal::world_pos(const ActionObserverCameraMove* msg) {
  return *msg->world_pos_;
}
void ActionObserverCameraMove::clear_world_pos() {
  if (world_pos_ != nullptr) world_pos_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
ActionObserverCameraMove::ActionObserverCameraMove()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionObserverCameraMove)
}
ActionObserverCameraMove::ActionObserverCameraMove(const ActionObserverCameraMove& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_world_pos()) {
    world_pos_ = new ::SC2APIProtocol::Point2D(*from.world_pos_);
  } else {
    world_pos_ = nullptr;
  }
  distance_ = from.distance_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionObserverCameraMove)
}

void ActionObserverCameraMove::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionObserverCameraMove_s2clientprotocol_2fsc2api_2eproto.base);
  ::memset(&world_pos_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&distance_) -
      reinterpret_cast<char*>(&world_pos_)) + sizeof(distance_));
}

ActionObserverCameraMove::~ActionObserverCameraMove() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ActionObserverCameraMove)
  SharedDtor();
}

void ActionObserverCameraMove::SharedDtor() {
  if (this != internal_default_instance()) delete world_pos_;
}

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


void ActionObserverCameraMove::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ActionObserverCameraMove)
  ::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 & 0x00000001u) {
    GOOGLE_DCHECK(world_pos_ != nullptr);
    world_pos_->Clear();
  }
  distance_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionObserverCameraMove::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .SC2APIProtocol.Point2D world_pos = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_world_pos(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float distance = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_distance(&has_bits);
          distance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.Point2D world_pos = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::world_pos(this), target, stream);
  }

  // optional float distance = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_distance(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ActionObserverCameraMove)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .SC2APIProtocol.Point2D world_pos = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *world_pos_);
    }

    // optional float distance = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 4;
    }

  }
  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 ActionObserverCameraMove::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionObserverCameraMove)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionObserverCameraMove* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionObserverCameraMove>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionObserverCameraMove)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionObserverCameraMove)
    MergeFrom(*source);
  }
}

void ActionObserverCameraMove::MergeFrom(const ActionObserverCameraMove& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ActionObserverCameraMove)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_world_pos()->::SC2APIProtocol::Point2D::MergeFrom(from._internal_world_pos());
    }
    if (cached_has_bits & 0x00000002u) {
      distance_ = from.distance_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void ActionObserverCameraMove::InternalSwap(ActionObserverCameraMove* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(world_pos_, other->world_pos_);
  swap(distance_, other->distance_);
}

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


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

void ActionObserverCameraFollowPlayer::InitAsDefaultInstance() {
}
class ActionObserverCameraFollowPlayer::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionObserverCameraFollowPlayer>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

ActionObserverCameraFollowPlayer::ActionObserverCameraFollowPlayer()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionObserverCameraFollowPlayer)
}
ActionObserverCameraFollowPlayer::ActionObserverCameraFollowPlayer(const ActionObserverCameraFollowPlayer& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  player_id_ = from.player_id_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionObserverCameraFollowPlayer)
}

void ActionObserverCameraFollowPlayer::SharedCtor() {
  player_id_ = 0u;
}

ActionObserverCameraFollowPlayer::~ActionObserverCameraFollowPlayer() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ActionObserverCameraFollowPlayer)
  SharedDtor();
}

void ActionObserverCameraFollowPlayer::SharedDtor() {
}

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


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

  player_id_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionObserverCameraFollowPlayer::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ActionObserverCameraFollowPlayer)
  return target;
}

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

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

  // optional uint32 player_id = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_player_id());
  }

  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 ActionObserverCameraFollowPlayer::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionObserverCameraFollowPlayer)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionObserverCameraFollowPlayer* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionObserverCameraFollowPlayer>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionObserverCameraFollowPlayer)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionObserverCameraFollowPlayer)
    MergeFrom(*source);
  }
}

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

  if (from._internal_has_player_id()) {
    _internal_set_player_id(from._internal_player_id());
  }
}

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

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

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

void ActionObserverCameraFollowPlayer::InternalSwap(ActionObserverCameraFollowPlayer* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(player_id_, other->player_id_);
}

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


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

void ActionObserverCameraFollowUnits::InitAsDefaultInstance() {
}
class ActionObserverCameraFollowUnits::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionObserverCameraFollowUnits>()._has_bits_);
};

ActionObserverCameraFollowUnits::ActionObserverCameraFollowUnits()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionObserverCameraFollowUnits)
}
ActionObserverCameraFollowUnits::ActionObserverCameraFollowUnits(const ActionObserverCameraFollowUnits& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      unit_tags_(from.unit_tags_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionObserverCameraFollowUnits)
}

void ActionObserverCameraFollowUnits::SharedCtor() {
}

ActionObserverCameraFollowUnits::~ActionObserverCameraFollowUnits() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.ActionObserverCameraFollowUnits)
  SharedDtor();
}

void ActionObserverCameraFollowUnits::SharedDtor() {
}

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


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

  unit_tags_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionObserverCameraFollowUnits::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated uint64 unit_tags = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_unit_tags(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser(_internal_mutable_unit_tags(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // repeated uint64 unit_tags = 1;
  for (int i = 0, n = this->_internal_unit_tags_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_unit_tags(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.ActionObserverCameraFollowUnits)
  return target;
}

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

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

  // repeated uint64 unit_tags = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt64Size(this->unit_tags_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_unit_tags_size());
    total_size += data_size;
  }

  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 ActionObserverCameraFollowUnits::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionObserverCameraFollowUnits)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionObserverCameraFollowUnits* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionObserverCameraFollowUnits>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionObserverCameraFollowUnits)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionObserverCameraFollowUnits)
    MergeFrom(*source);
  }
}

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

  unit_tags_.MergeFrom(from.unit_tags_);
}

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

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

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

void ActionObserverCameraFollowUnits::InternalSwap(ActionObserverCameraFollowUnits* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  unit_tags_.InternalSwap(&other->unit_tags_);
}

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


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

void PlayerResult::InitAsDefaultInstance() {
}
class PlayerResult::_Internal {
 public:
  using HasBits = decltype(std::declval<PlayerResult>()._has_bits_);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_result(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

PlayerResult::PlayerResult()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.PlayerResult)
}
PlayerResult::PlayerResult(const PlayerResult& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&player_id_, &from.player_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&result_) -
    reinterpret_cast<char*>(&player_id_)) + sizeof(result_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.PlayerResult)
}

void PlayerResult::SharedCtor() {
  player_id_ = 0u;
  result_ = 1;
}

PlayerResult::~PlayerResult() {
  // @@protoc_insertion_point(destructor:SC2APIProtocol.PlayerResult)
  SharedDtor();
}

void PlayerResult::SharedDtor() {
}

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


void PlayerResult::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.PlayerResult)
  ::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 & 0x00000003u) {
    player_id_ = 0u;
    result_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* PlayerResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 player_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_player_id(&has_bits);
          player_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Result result = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::Result_IsValid(val))) {
            _internal_set_result(static_cast<::SC2APIProtocol::Result>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional uint32 player_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_player_id(), target);
  }

  // optional .SC2APIProtocol.Result result = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_result(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SC2APIProtocol.PlayerResult)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional uint32 player_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_player_id());
    }

    // optional .SC2APIProtocol.Result result = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_result());
    }

  }
  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 PlayerResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.PlayerResult)
  GOOGLE_DCHECK_NE(&from, this);
  const PlayerResult* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PlayerResult>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.PlayerResult)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.PlayerResult)
    MergeFrom(*source);
  }
}

void PlayerResult::MergeFrom(const PlayerResult& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.PlayerResult)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      player_id_ = from.player_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      result_ = from.result_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void PlayerResult::InternalSwap(PlayerResult* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(player_id_, other->player_id_);
  swap(result_, other->result_);
}

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace SC2APIProtocol
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Request* Arena::CreateMaybeMessage< ::SC2APIProtocol::Request >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Request >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Response* Arena::CreateMaybeMessage< ::SC2APIProtocol::Response >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Response >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestCreateGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestCreateGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestCreateGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::LocalMap* Arena::CreateMaybeMessage< ::SC2APIProtocol::LocalMap >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::LocalMap >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseCreateGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseCreateGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseCreateGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestJoinGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestJoinGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestJoinGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PortSet* Arena::CreateMaybeMessage< ::SC2APIProtocol::PortSet >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PortSet >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseJoinGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseJoinGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseJoinGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestRestartGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestRestartGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestRestartGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseRestartGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseRestartGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseRestartGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestStartReplay* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestStartReplay >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestStartReplay >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseStartReplay* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseStartReplay >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseStartReplay >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestMapCommand* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestMapCommand >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestMapCommand >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseMapCommand* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseMapCommand >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseMapCommand >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestLeaveGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestLeaveGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestLeaveGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseLeaveGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseLeaveGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseLeaveGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestQuickSave* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestQuickSave >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestQuickSave >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseQuickSave* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseQuickSave >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseQuickSave >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestQuickLoad* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestQuickLoad >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestQuickLoad >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseQuickLoad* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseQuickLoad >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseQuickLoad >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestQuit* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestQuit >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestQuit >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseQuit* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseQuit >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseQuit >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestGameInfo* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestGameInfo >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestGameInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseGameInfo* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseGameInfo >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseGameInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestObservation* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestObservation >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestObservation >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseObservation* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseObservation >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseObservation >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ChatReceived* Arena::CreateMaybeMessage< ::SC2APIProtocol::ChatReceived >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ChatReceived >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestAction* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestAction >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestAction >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseAction* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseAction >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseAction >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestObserverAction* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestObserverAction >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestObserverAction >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseObserverAction* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseObserverAction >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseObserverAction >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestStep* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestStep >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestStep >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseStep* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseStep >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseStep >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestData* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestData >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestData >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseData* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseData >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseData >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestSaveReplay* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestSaveReplay >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestSaveReplay >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseSaveReplay* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseSaveReplay >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseSaveReplay >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestReplayInfo* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestReplayInfo >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestReplayInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PlayerInfoExtra* Arena::CreateMaybeMessage< ::SC2APIProtocol::PlayerInfoExtra >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PlayerInfoExtra >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseReplayInfo* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseReplayInfo >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseReplayInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestAvailableMaps* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestAvailableMaps >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestAvailableMaps >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseAvailableMaps* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseAvailableMaps >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseAvailableMaps >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestSaveMap* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestSaveMap >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestSaveMap >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseSaveMap* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseSaveMap >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseSaveMap >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestPing* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestPing >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestPing >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponsePing* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponsePing >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponsePing >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RequestDebug* Arena::CreateMaybeMessage< ::SC2APIProtocol::RequestDebug >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RequestDebug >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ResponseDebug* Arena::CreateMaybeMessage< ::SC2APIProtocol::ResponseDebug >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ResponseDebug >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PlayerSetup* Arena::CreateMaybeMessage< ::SC2APIProtocol::PlayerSetup >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PlayerSetup >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::SpatialCameraSetup* Arena::CreateMaybeMessage< ::SC2APIProtocol::SpatialCameraSetup >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::SpatialCameraSetup >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::InterfaceOptions* Arena::CreateMaybeMessage< ::SC2APIProtocol::InterfaceOptions >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::InterfaceOptions >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PlayerInfo* Arena::CreateMaybeMessage< ::SC2APIProtocol::PlayerInfo >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PlayerInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PlayerCommon* Arena::CreateMaybeMessage< ::SC2APIProtocol::PlayerCommon >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PlayerCommon >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Observation* Arena::CreateMaybeMessage< ::SC2APIProtocol::Observation >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Observation >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Action* Arena::CreateMaybeMessage< ::SC2APIProtocol::Action >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Action >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionChat* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionChat >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionChat >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionError* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionError >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionError >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ObserverAction* Arena::CreateMaybeMessage< ::SC2APIProtocol::ObserverAction >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ObserverAction >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionObserverPlayerPerspective* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionObserverPlayerPerspective >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionObserverPlayerPerspective >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionObserverCameraMove* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionObserverCameraMove >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionObserverCameraMove >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionObserverCameraFollowPlayer* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionObserverCameraFollowPlayer >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionObserverCameraFollowPlayer >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionObserverCameraFollowUnits* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionObserverCameraFollowUnits >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionObserverCameraFollowUnits >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PlayerResult* Arena::CreateMaybeMessage< ::SC2APIProtocol::PlayerResult >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PlayerResult >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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