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

#include "s2clientprotocol/debug.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_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Color_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugBox_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_DebugCreateUnit_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DebugEndGame_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DebugKillUnit_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugLine_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DebugSetScore_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DebugSetUnitValue_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DebugTestProcess_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugText_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fdebug_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Line_s2clientprotocol_2fdebug_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Point_s2clientprotocol_2fcommon_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Point2D_s2clientprotocol_2fcommon_2eproto;
namespace SC2APIProtocol {
class DebugCommandDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugCommand> _instance;
  const ::SC2APIProtocol::DebugDraw* draw_;
  int game_state_;
  const ::SC2APIProtocol::DebugCreateUnit* create_unit_;
  const ::SC2APIProtocol::DebugKillUnit* kill_unit_;
  const ::SC2APIProtocol::DebugTestProcess* test_process_;
  const ::SC2APIProtocol::DebugSetScore* score_;
  const ::SC2APIProtocol::DebugEndGame* end_game_;
  const ::SC2APIProtocol::DebugSetUnitValue* unit_value_;
} _DebugCommand_default_instance_;
class DebugDrawDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugDraw> _instance;
} _DebugDraw_default_instance_;
class LineDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Line> _instance;
} _Line_default_instance_;
class ColorDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Color> _instance;
} _Color_default_instance_;
class DebugTextDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugText> _instance;
} _DebugText_default_instance_;
class DebugLineDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugLine> _instance;
} _DebugLine_default_instance_;
class DebugBoxDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugBox> _instance;
} _DebugBox_default_instance_;
class DebugSphereDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugSphere> _instance;
} _DebugSphere_default_instance_;
class DebugCreateUnitDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugCreateUnit> _instance;
} _DebugCreateUnit_default_instance_;
class DebugKillUnitDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugKillUnit> _instance;
} _DebugKillUnit_default_instance_;
class DebugTestProcessDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugTestProcess> _instance;
} _DebugTestProcess_default_instance_;
class DebugSetScoreDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugSetScore> _instance;
} _DebugSetScore_default_instance_;
class DebugEndGameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugEndGame> _instance;
} _DebugEndGame_default_instance_;
class DebugSetUnitValueDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DebugSetUnitValue> _instance;
} _DebugSetUnitValue_default_instance_;
}  // namespace SC2APIProtocol
static void InitDefaultsscc_info_Color_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugBox_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugBox_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_DebugBox_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_Color_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_Point_s2clientprotocol_2fcommon_2eproto.base,}};

static void InitDefaultsscc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 7, 0, InitDefaultsscc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugCreateUnit_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugKillUnit_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugTestProcess_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugSetScore_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugEndGame_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugSetUnitValue_s2clientprotocol_2fdebug_2eproto.base,}};

static void InitDefaultsscc_info_DebugCreateUnit_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_DebugText_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugLine_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugBox_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto.base,}};

static void InitDefaultsscc_info_DebugEndGame_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugKillUnit_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugLine_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugLine_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_DebugLine_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_Color_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_Line_s2clientprotocol_2fdebug_2eproto.base,}};

static void InitDefaultsscc_info_DebugSetScore_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugSetUnitValue_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_Color_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_Point_s2clientprotocol_2fcommon_2eproto.base,}};

static void InitDefaultsscc_info_DebugTestProcess_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_DebugText_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_DebugText_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_DebugText_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_Color_s2clientprotocol_2fdebug_2eproto.base,
      &scc_info_Point_s2clientprotocol_2fcommon_2eproto.base,}};

static void InitDefaultsscc_info_Line_s2clientprotocol_2fdebug_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Line_s2clientprotocol_2fdebug_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Line_s2clientprotocol_2fdebug_2eproto}, {
      &scc_info_Point_s2clientprotocol_2fcommon_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_s2clientprotocol_2fdebug_2eproto[14];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_s2clientprotocol_2fdebug_2eproto[4];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_s2clientprotocol_2fdebug_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_s2clientprotocol_2fdebug_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCommand, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCommand, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCommand, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, draw_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, game_state_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, create_unit_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, kill_unit_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, test_process_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, score_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, end_game_),
  offsetof(::SC2APIProtocol::DebugCommandDefaultTypeInternal, unit_value_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCommand, command_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugDraw, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugDraw, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugDraw, text_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugDraw, lines_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugDraw, boxes_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugDraw, spheres_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Line, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Line, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Line, p0_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Line, p1_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Color, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Color, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Color, r_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Color, g_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Color, b_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, color_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, text_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, virtual_pos_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, world_pos_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugText, size_),
  1,
  0,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugLine, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugLine, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugLine, color_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugLine, line_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugBox, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugBox, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugBox, color_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugBox, min_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugBox, max_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSphere, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSphere, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSphere, color_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSphere, p_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSphere, r_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCreateUnit, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCreateUnit, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCreateUnit, unit_type_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCreateUnit, owner_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCreateUnit, pos_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugCreateUnit, quantity_),
  1,
  2,
  0,
  3,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugKillUnit, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugKillUnit, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugKillUnit, tag_),
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugTestProcess, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugTestProcess, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugTestProcess, test_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugTestProcess, delay_ms_),
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetScore, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetScore, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetScore, score_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugEndGame, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugEndGame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugEndGame, end_result_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetUnitValue, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetUnitValue, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetUnitValue, unit_value_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetUnitValue, value_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::DebugSetUnitValue, unit_tag_),
  2,
  1,
  0,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 14, sizeof(::SC2APIProtocol::DebugCommand)},
  { 22, 31, sizeof(::SC2APIProtocol::DebugDraw)},
  { 35, 42, sizeof(::SC2APIProtocol::Line)},
  { 44, 52, sizeof(::SC2APIProtocol::Color)},
  { 55, 65, sizeof(::SC2APIProtocol::DebugText)},
  { 70, 77, sizeof(::SC2APIProtocol::DebugLine)},
  { 79, 87, sizeof(::SC2APIProtocol::DebugBox)},
  { 90, 98, sizeof(::SC2APIProtocol::DebugSphere)},
  { 101, 110, sizeof(::SC2APIProtocol::DebugCreateUnit)},
  { 114, 120, sizeof(::SC2APIProtocol::DebugKillUnit)},
  { 121, 128, sizeof(::SC2APIProtocol::DebugTestProcess)},
  { 130, 136, sizeof(::SC2APIProtocol::DebugSetScore)},
  { 137, 143, sizeof(::SC2APIProtocol::DebugEndGame)},
  { 144, 152, sizeof(::SC2APIProtocol::DebugSetUnitValue)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugCommand_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugDraw_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Line_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Color_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugText_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugLine_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugBox_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugSphere_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugCreateUnit_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugKillUnit_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugTestProcess_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugSetScore_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugEndGame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_DebugSetUnitValue_default_instance_),
};

const char descriptor_table_protodef_s2clientprotocol_2fdebug_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\034s2clientprotocol/debug.proto\022\016SC2APIPr"
  "otocol\032\035s2clientprotocol/common.proto\"\273\003"
  "\n\014DebugCommand\022)\n\004draw\030\001 \001(\0132\031.SC2APIPro"
  "tocol.DebugDrawH\000\0224\n\ngame_state\030\002 \001(\0162\036."
  "SC2APIProtocol.DebugGameStateH\000\0226\n\013creat"
  "e_unit\030\003 \001(\0132\037.SC2APIProtocol.DebugCreat"
  "eUnitH\000\0222\n\tkill_unit\030\004 \001(\0132\035.SC2APIProto"
  "col.DebugKillUnitH\000\0228\n\014test_process\030\005 \001("
  "\0132 .SC2APIProtocol.DebugTestProcessH\000\022.\n"
  "\005score\030\006 \001(\0132\035.SC2APIProtocol.DebugSetSc"
  "oreH\000\0220\n\010end_game\030\007 \001(\0132\034.SC2APIProtocol"
  ".DebugEndGameH\000\0227\n\nunit_value\030\010 \001(\0132!.SC"
  "2APIProtocol.DebugSetUnitValueH\000B\t\n\007comm"
  "and\"\265\001\n\tDebugDraw\022\'\n\004text\030\001 \003(\0132\031.SC2API"
  "Protocol.DebugText\022(\n\005lines\030\002 \003(\0132\031.SC2A"
  "PIProtocol.DebugLine\022\'\n\005boxes\030\003 \003(\0132\030.SC"
  "2APIProtocol.DebugBox\022,\n\007spheres\030\004 \003(\0132\033"
  ".SC2APIProtocol.DebugSphere\"L\n\004Line\022!\n\002p"
  "0\030\001 \001(\0132\025.SC2APIProtocol.Point\022!\n\002p1\030\002 \001"
  "(\0132\025.SC2APIProtocol.Point\"(\n\005Color\022\t\n\001r\030"
  "\001 \001(\r\022\t\n\001g\030\002 \001(\r\022\t\n\001b\030\003 \001(\r\"\243\001\n\tDebugTex"
  "t\022$\n\005color\030\001 \001(\0132\025.SC2APIProtocol.Color\022"
  "\014\n\004text\030\002 \001(\t\022*\n\013virtual_pos\030\003 \001(\0132\025.SC2"
  "APIProtocol.Point\022(\n\tworld_pos\030\004 \001(\0132\025.S"
  "C2APIProtocol.Point\022\014\n\004size\030\005 \001(\r\"U\n\tDeb"
  "ugLine\022$\n\005color\030\001 \001(\0132\025.SC2APIProtocol.C"
  "olor\022\"\n\004line\030\002 \001(\0132\024.SC2APIProtocol.Line"
  "\"x\n\010DebugBox\022$\n\005color\030\001 \001(\0132\025.SC2APIProt"
  "ocol.Color\022\"\n\003min\030\002 \001(\0132\025.SC2APIProtocol"
  ".Point\022\"\n\003max\030\003 \001(\0132\025.SC2APIProtocol.Poi"
  "nt\"`\n\013DebugSphere\022$\n\005color\030\001 \001(\0132\025.SC2AP"
  "IProtocol.Color\022 \n\001p\030\002 \001(\0132\025.SC2APIProto"
  "col.Point\022\t\n\001r\030\003 \001(\002\"k\n\017DebugCreateUnit\022"
  "\021\n\tunit_type\030\001 \001(\r\022\r\n\005owner\030\002 \001(\005\022$\n\003pos"
  "\030\003 \001(\0132\027.SC2APIProtocol.Point2D\022\020\n\010quant"
  "ity\030\004 \001(\r\"\034\n\rDebugKillUnit\022\013\n\003tag\030\001 \003(\004\""
  "\200\001\n\020DebugTestProcess\0223\n\004test\030\001 \001(\0162%.SC2"
  "APIProtocol.DebugTestProcess.Test\022\020\n\010del"
  "ay_ms\030\002 \001(\005\"%\n\004Test\022\010\n\004hang\020\001\022\t\n\005crash\020\002"
  "\022\010\n\004exit\020\003\"\036\n\rDebugSetScore\022\r\n\005score\030\001 \001"
  "(\002\"z\n\014DebugEndGame\022:\n\nend_result\030\001 \001(\0162&"
  ".SC2APIProtocol.DebugEndGame.EndResult\"."
  "\n\tEndResult\022\r\n\tSurrender\020\001\022\022\n\016DeclareVic"
  "tory\020\002\"\245\001\n\021DebugSetUnitValue\022\?\n\nunit_val"
  "ue\030\001 \001(\0162+.SC2APIProtocol.DebugSetUnitVa"
  "lue.UnitValue\022\r\n\005value\030\002 \001(\002\022\020\n\010unit_tag"
  "\030\003 \001(\004\".\n\tUnitValue\022\n\n\006Energy\020\001\022\010\n\004Life\020"
  "\002\022\013\n\007Shields\020\003*\262\001\n\016DebugGameState\022\014\n\010sho"
  "w_map\020\001\022\021\n\rcontrol_enemy\020\002\022\010\n\004food\020\003\022\010\n\004"
  "free\020\004\022\021\n\rall_resources\020\005\022\007\n\003god\020\006\022\014\n\010mi"
  "nerals\020\007\022\007\n\003gas\020\010\022\014\n\010cooldown\020\t\022\r\n\ttech_"
  "tree\020\n\022\013\n\007upgrade\020\013\022\016\n\nfast_build\020\014"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_s2clientprotocol_2fdebug_2eproto_deps[1] = {
  &::descriptor_table_s2clientprotocol_2fcommon_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_s2clientprotocol_2fdebug_2eproto_sccs[14] = {
  &scc_info_Color_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugBox_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugCreateUnit_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugEndGame_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugKillUnit_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugLine_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugSetScore_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugSetUnitValue_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugTestProcess_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_DebugText_s2clientprotocol_2fdebug_2eproto.base,
  &scc_info_Line_s2clientprotocol_2fdebug_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_s2clientprotocol_2fdebug_2eproto_once;
static bool descriptor_table_s2clientprotocol_2fdebug_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_s2clientprotocol_2fdebug_2eproto = {
  &descriptor_table_s2clientprotocol_2fdebug_2eproto_initialized, descriptor_table_protodef_s2clientprotocol_2fdebug_2eproto, "s2clientprotocol/debug.proto", 2075,
  &descriptor_table_s2clientprotocol_2fdebug_2eproto_once, descriptor_table_s2clientprotocol_2fdebug_2eproto_sccs, descriptor_table_s2clientprotocol_2fdebug_2eproto_deps, 14, 1,
  schemas, file_default_instances, TableStruct_s2clientprotocol_2fdebug_2eproto::offsets,
  file_level_metadata_s2clientprotocol_2fdebug_2eproto, 14, file_level_enum_descriptors_s2clientprotocol_2fdebug_2eproto, file_level_service_descriptors_s2clientprotocol_2fdebug_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_s2clientprotocol_2fdebug_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_s2clientprotocol_2fdebug_2eproto)), true);
namespace SC2APIProtocol {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugTestProcess_Test_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fdebug_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fdebug_2eproto[0];
}
bool DebugTestProcess_Test_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr DebugTestProcess_Test DebugTestProcess::hang;
constexpr DebugTestProcess_Test DebugTestProcess::crash;
constexpr DebugTestProcess_Test DebugTestProcess::exit;
constexpr DebugTestProcess_Test DebugTestProcess::Test_MIN;
constexpr DebugTestProcess_Test DebugTestProcess::Test_MAX;
constexpr int DebugTestProcess::Test_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugEndGame_EndResult_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fdebug_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fdebug_2eproto[1];
}
bool DebugEndGame_EndResult_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr DebugEndGame_EndResult DebugEndGame::Surrender;
constexpr DebugEndGame_EndResult DebugEndGame::DeclareVictory;
constexpr DebugEndGame_EndResult DebugEndGame::EndResult_MIN;
constexpr DebugEndGame_EndResult DebugEndGame::EndResult_MAX;
constexpr int DebugEndGame::EndResult_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugSetUnitValue_UnitValue_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fdebug_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fdebug_2eproto[2];
}
bool DebugSetUnitValue_UnitValue_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr DebugSetUnitValue_UnitValue DebugSetUnitValue::Energy;
constexpr DebugSetUnitValue_UnitValue DebugSetUnitValue::Life;
constexpr DebugSetUnitValue_UnitValue DebugSetUnitValue::Shields;
constexpr DebugSetUnitValue_UnitValue DebugSetUnitValue::UnitValue_MIN;
constexpr DebugSetUnitValue_UnitValue DebugSetUnitValue::UnitValue_MAX;
constexpr int DebugSetUnitValue::UnitValue_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugGameState_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_s2clientprotocol_2fdebug_2eproto);
  return file_level_enum_descriptors_s2clientprotocol_2fdebug_2eproto[3];
}
bool DebugGameState_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:
      return true;
    default:
      return false;
  }
}


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

void DebugCommand::InitAsDefaultInstance() {
  ::SC2APIProtocol::_DebugCommand_default_instance_.draw_ = const_cast< ::SC2APIProtocol::DebugDraw*>(
      ::SC2APIProtocol::DebugDraw::internal_default_instance());
  ::SC2APIProtocol::_DebugCommand_default_instance_.game_state_ = 1;
  ::SC2APIProtocol::_DebugCommand_default_instance_.create_unit_ = const_cast< ::SC2APIProtocol::DebugCreateUnit*>(
      ::SC2APIProtocol::DebugCreateUnit::internal_default_instance());
  ::SC2APIProtocol::_DebugCommand_default_instance_.kill_unit_ = const_cast< ::SC2APIProtocol::DebugKillUnit*>(
      ::SC2APIProtocol::DebugKillUnit::internal_default_instance());
  ::SC2APIProtocol::_DebugCommand_default_instance_.test_process_ = const_cast< ::SC2APIProtocol::DebugTestProcess*>(
      ::SC2APIProtocol::DebugTestProcess::internal_default_instance());
  ::SC2APIProtocol::_DebugCommand_default_instance_.score_ = const_cast< ::SC2APIProtocol::DebugSetScore*>(
      ::SC2APIProtocol::DebugSetScore::internal_default_instance());
  ::SC2APIProtocol::_DebugCommand_default_instance_.end_game_ = const_cast< ::SC2APIProtocol::DebugEndGame*>(
      ::SC2APIProtocol::DebugEndGame::internal_default_instance());
  ::SC2APIProtocol::_DebugCommand_default_instance_.unit_value_ = const_cast< ::SC2APIProtocol::DebugSetUnitValue*>(
      ::SC2APIProtocol::DebugSetUnitValue::internal_default_instance());
}
class DebugCommand::_Internal {
 public:
  using HasBits = decltype(std::declval<DebugCommand>()._has_bits_);
  static const ::SC2APIProtocol::DebugDraw& draw(const DebugCommand* msg);
  static const ::SC2APIProtocol::DebugCreateUnit& create_unit(const DebugCommand* msg);
  static const ::SC2APIProtocol::DebugKillUnit& kill_unit(const DebugCommand* msg);
  static const ::SC2APIProtocol::DebugTestProcess& test_process(const DebugCommand* msg);
  static const ::SC2APIProtocol::DebugSetScore& score(const DebugCommand* msg);
  static const ::SC2APIProtocol::DebugEndGame& end_game(const DebugCommand* msg);
  static const ::SC2APIProtocol::DebugSetUnitValue& unit_value(const DebugCommand* msg);
};

const ::SC2APIProtocol::DebugDraw&
DebugCommand::_Internal::draw(const DebugCommand* msg) {
  return *msg->command_.draw_;
}
const ::SC2APIProtocol::DebugCreateUnit&
DebugCommand::_Internal::create_unit(const DebugCommand* msg) {
  return *msg->command_.create_unit_;
}
const ::SC2APIProtocol::DebugKillUnit&
DebugCommand::_Internal::kill_unit(const DebugCommand* msg) {
  return *msg->command_.kill_unit_;
}
const ::SC2APIProtocol::DebugTestProcess&
DebugCommand::_Internal::test_process(const DebugCommand* msg) {
  return *msg->command_.test_process_;
}
const ::SC2APIProtocol::DebugSetScore&
DebugCommand::_Internal::score(const DebugCommand* msg) {
  return *msg->command_.score_;
}
const ::SC2APIProtocol::DebugEndGame&
DebugCommand::_Internal::end_game(const DebugCommand* msg) {
  return *msg->command_.end_game_;
}
const ::SC2APIProtocol::DebugSetUnitValue&
DebugCommand::_Internal::unit_value(const DebugCommand* msg) {
  return *msg->command_.unit_value_;
}
void DebugCommand::set_allocated_draw(::SC2APIProtocol::DebugDraw* draw) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (draw) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      draw = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, draw, submessage_arena);
    }
    set_has_draw();
    command_.draw_ = draw;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.draw)
}
void DebugCommand::set_allocated_create_unit(::SC2APIProtocol::DebugCreateUnit* create_unit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (create_unit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      create_unit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, create_unit, submessage_arena);
    }
    set_has_create_unit();
    command_.create_unit_ = create_unit;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.create_unit)
}
void DebugCommand::set_allocated_kill_unit(::SC2APIProtocol::DebugKillUnit* kill_unit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (kill_unit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      kill_unit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, kill_unit, submessage_arena);
    }
    set_has_kill_unit();
    command_.kill_unit_ = kill_unit;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.kill_unit)
}
void DebugCommand::set_allocated_test_process(::SC2APIProtocol::DebugTestProcess* test_process) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (test_process) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      test_process = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, test_process, submessage_arena);
    }
    set_has_test_process();
    command_.test_process_ = test_process;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.test_process)
}
void DebugCommand::set_allocated_score(::SC2APIProtocol::DebugSetScore* score) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (score) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      score = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, score, submessage_arena);
    }
    set_has_score();
    command_.score_ = score;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.score)
}
void DebugCommand::set_allocated_end_game(::SC2APIProtocol::DebugEndGame* end_game) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (end_game) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      end_game = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, end_game, submessage_arena);
    }
    set_has_end_game();
    command_.end_game_ = end_game;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.end_game)
}
void DebugCommand::set_allocated_unit_value(::SC2APIProtocol::DebugSetUnitValue* unit_value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_command();
  if (unit_value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      unit_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unit_value, submessage_arena);
    }
    set_has_unit_value();
    command_.unit_value_ = unit_value;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.DebugCommand.unit_value)
}
DebugCommand::DebugCommand()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugCommand)
}
DebugCommand::DebugCommand(const DebugCommand& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_command();
  switch (from.command_case()) {
    case kDraw: {
      _internal_mutable_draw()->::SC2APIProtocol::DebugDraw::MergeFrom(from._internal_draw());
      break;
    }
    case kGameState: {
      _internal_set_game_state(from._internal_game_state());
      break;
    }
    case kCreateUnit: {
      _internal_mutable_create_unit()->::SC2APIProtocol::DebugCreateUnit::MergeFrom(from._internal_create_unit());
      break;
    }
    case kKillUnit: {
      _internal_mutable_kill_unit()->::SC2APIProtocol::DebugKillUnit::MergeFrom(from._internal_kill_unit());
      break;
    }
    case kTestProcess: {
      _internal_mutable_test_process()->::SC2APIProtocol::DebugTestProcess::MergeFrom(from._internal_test_process());
      break;
    }
    case kScore: {
      _internal_mutable_score()->::SC2APIProtocol::DebugSetScore::MergeFrom(from._internal_score());
      break;
    }
    case kEndGame: {
      _internal_mutable_end_game()->::SC2APIProtocol::DebugEndGame::MergeFrom(from._internal_end_game());
      break;
    }
    case kUnitValue: {
      _internal_mutable_unit_value()->::SC2APIProtocol::DebugSetUnitValue::MergeFrom(from._internal_unit_value());
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugCommand)
}

void DebugCommand::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugCommand_s2clientprotocol_2fdebug_2eproto.base);
  clear_has_command();
}

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

void DebugCommand::SharedDtor() {
  if (has_command()) {
    clear_command();
  }
}

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


void DebugCommand::clear_command() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.DebugCommand)
  switch (command_case()) {
    case kDraw: {
      delete command_.draw_;
      break;
    }
    case kGameState: {
      // No need to clear
      break;
    }
    case kCreateUnit: {
      delete command_.create_unit_;
      break;
    }
    case kKillUnit: {
      delete command_.kill_unit_;
      break;
    }
    case kTestProcess: {
      delete command_.test_process_;
      break;
    }
    case kScore: {
      delete command_.score_;
      break;
    }
    case kEndGame: {
      delete command_.end_game_;
      break;
    }
    case kUnitValue: {
      delete command_.unit_value_;
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = COMMAND_NOT_SET;
}


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

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

const char* DebugCommand::_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.DebugDraw draw = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_draw(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugGameState game_state = 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::DebugGameState_IsValid(val))) {
            _internal_set_game_state(static_cast<::SC2APIProtocol::DebugGameState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugCreateUnit create_unit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_create_unit(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugKillUnit kill_unit = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_kill_unit(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugTestProcess test_process = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_test_process(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugSetScore score = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_score(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugEndGame end_game = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_end_game(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.DebugSetUnitValue unit_value = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_value(), 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* DebugCommand::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugCommand)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (command_case()) {
    case kDraw: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::draw(this), target, stream);
      break;
    }
    case kGameState: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        2, this->_internal_game_state(), target);
      break;
    }
    case kCreateUnit: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::create_unit(this), target, stream);
      break;
    }
    case kKillUnit: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::kill_unit(this), target, stream);
      break;
    }
    case kTestProcess: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::test_process(this), target, stream);
      break;
    }
    case kScore: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::score(this), target, stream);
      break;
    }
    case kEndGame: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::end_game(this), target, stream);
      break;
    }
    case kUnitValue: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          8, _Internal::unit_value(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.DebugCommand)
  return target;
}

size_t DebugCommand::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugCommand)
  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 (command_case()) {
    // optional .SC2APIProtocol.DebugDraw draw = 1;
    case kDraw: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.draw_);
      break;
    }
    // optional .SC2APIProtocol.DebugGameState game_state = 2;
    case kGameState: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_game_state());
      break;
    }
    // optional .SC2APIProtocol.DebugCreateUnit create_unit = 3;
    case kCreateUnit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.create_unit_);
      break;
    }
    // optional .SC2APIProtocol.DebugKillUnit kill_unit = 4;
    case kKillUnit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.kill_unit_);
      break;
    }
    // optional .SC2APIProtocol.DebugTestProcess test_process = 5;
    case kTestProcess: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.test_process_);
      break;
    }
    // optional .SC2APIProtocol.DebugSetScore score = 6;
    case kScore: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.score_);
      break;
    }
    // optional .SC2APIProtocol.DebugEndGame end_game = 7;
    case kEndGame: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.end_game_);
      break;
    }
    // optional .SC2APIProtocol.DebugSetUnitValue unit_value = 8;
    case kUnitValue: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *command_.unit_value_);
      break;
    }
    case COMMAND_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 DebugCommand::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.DebugCommand)
  GOOGLE_DCHECK_NE(&from, this);
  const DebugCommand* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DebugCommand>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.DebugCommand)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.DebugCommand)
    MergeFrom(*source);
  }
}

void DebugCommand::MergeFrom(const DebugCommand& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugCommand)
  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.command_case()) {
    case kDraw: {
      _internal_mutable_draw()->::SC2APIProtocol::DebugDraw::MergeFrom(from._internal_draw());
      break;
    }
    case kGameState: {
      _internal_set_game_state(from._internal_game_state());
      break;
    }
    case kCreateUnit: {
      _internal_mutable_create_unit()->::SC2APIProtocol::DebugCreateUnit::MergeFrom(from._internal_create_unit());
      break;
    }
    case kKillUnit: {
      _internal_mutable_kill_unit()->::SC2APIProtocol::DebugKillUnit::MergeFrom(from._internal_kill_unit());
      break;
    }
    case kTestProcess: {
      _internal_mutable_test_process()->::SC2APIProtocol::DebugTestProcess::MergeFrom(from._internal_test_process());
      break;
    }
    case kScore: {
      _internal_mutable_score()->::SC2APIProtocol::DebugSetScore::MergeFrom(from._internal_score());
      break;
    }
    case kEndGame: {
      _internal_mutable_end_game()->::SC2APIProtocol::DebugEndGame::MergeFrom(from._internal_end_game());
      break;
    }
    case kUnitValue: {
      _internal_mutable_unit_value()->::SC2APIProtocol::DebugSetUnitValue::MergeFrom(from._internal_unit_value());
      break;
    }
    case COMMAND_NOT_SET: {
      break;
    }
  }
}

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

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

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

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

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


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

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

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

void DebugDraw::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugDraw_s2clientprotocol_2fdebug_2eproto.base);
}

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

void DebugDraw::SharedDtor() {
}

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


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

  text_.Clear();
  lines_.Clear();
  boxes_.Clear();
  spheres_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugDraw::_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.DebugText text = 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_text(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.DebugLine lines = 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_lines(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.DebugBox boxes = 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_boxes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .SC2APIProtocol.DebugSphere spheres = 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_spheres(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(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* DebugDraw::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugDraw)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // repeated .SC2APIProtocol.DebugSphere spheres = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_spheres_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_spheres(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.DebugDraw)
  return target;
}

size_t DebugDraw::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugDraw)
  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.DebugText text = 1;
  total_size += 1UL * this->_internal_text_size();
  for (const auto& msg : this->text_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.DebugLine lines = 2;
  total_size += 1UL * this->_internal_lines_size();
  for (const auto& msg : this->lines_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.DebugBox boxes = 3;
  total_size += 1UL * this->_internal_boxes_size();
  for (const auto& msg : this->boxes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .SC2APIProtocol.DebugSphere spheres = 4;
  total_size += 1UL * this->_internal_spheres_size();
  for (const auto& msg : this->spheres_) {
    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 DebugDraw::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.DebugDraw)
  GOOGLE_DCHECK_NE(&from, this);
  const DebugDraw* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DebugDraw>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.DebugDraw)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.DebugDraw)
    MergeFrom(*source);
  }
}

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

  text_.MergeFrom(from.text_);
  lines_.MergeFrom(from.lines_);
  boxes_.MergeFrom(from.boxes_);
  spheres_.MergeFrom(from.spheres_);
}

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

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

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

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

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


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

void Line::InitAsDefaultInstance() {
  ::SC2APIProtocol::_Line_default_instance_._instance.get_mutable()->p0_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
  ::SC2APIProtocol::_Line_default_instance_._instance.get_mutable()->p1_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
}
class Line::_Internal {
 public:
  using HasBits = decltype(std::declval<Line>()._has_bits_);
  static const ::SC2APIProtocol::Point& p0(const Line* msg);
  static void set_has_p0(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Point& p1(const Line* msg);
  static void set_has_p1(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::Point&
Line::_Internal::p0(const Line* msg) {
  return *msg->p0_;
}
const ::SC2APIProtocol::Point&
Line::_Internal::p1(const Line* msg) {
  return *msg->p1_;
}
void Line::clear_p0() {
  if (p0_ != nullptr) p0_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void Line::clear_p1() {
  if (p1_ != nullptr) p1_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
Line::Line()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.Line)
}
Line::Line(const Line& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_p0()) {
    p0_ = new ::SC2APIProtocol::Point(*from.p0_);
  } else {
    p0_ = nullptr;
  }
  if (from._internal_has_p1()) {
    p1_ = new ::SC2APIProtocol::Point(*from.p1_);
  } else {
    p1_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.Line)
}

void Line::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Line_s2clientprotocol_2fdebug_2eproto.base);
  ::memset(&p0_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&p1_) -
      reinterpret_cast<char*>(&p0_)) + sizeof(p1_));
}

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

void Line::SharedDtor() {
  if (this != internal_default_instance()) delete p0_;
  if (this != internal_default_instance()) delete p1_;
}

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


void Line::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.Line)
  ::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(p0_ != nullptr);
      p0_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(p1_ != nullptr);
      p1_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Line::_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.Point p0 = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_p0(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point p1 = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_p1(), 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* Line::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.Line)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .SC2APIProtocol.Point p1 = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::p1(this), 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.Line)
  return target;
}

size_t Line::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.Line)
  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.Point p0 = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *p0_);
    }

    // optional .SC2APIProtocol.Point p1 = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *p1_);
    }

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

void Line::MergeFrom(const Line& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.Line)
  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_p0()->::SC2APIProtocol::Point::MergeFrom(from._internal_p0());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_p1()->::SC2APIProtocol::Point::MergeFrom(from._internal_p1());
    }
  }
}

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

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

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

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

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


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

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

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

void Color::SharedCtor() {
  ::memset(&r_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&b_) -
      reinterpret_cast<char*>(&r_)) + sizeof(b_));
}

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

void Color::SharedDtor() {
}

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


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

const char* Color::_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 r = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_r(&has_bits);
          r_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 g = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_g(&has_bits);
          g_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 b = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_b(&has_bits);
          b_ = ::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* Color::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.Color)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional uint32 b = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_b(), 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.Color)
  return target;
}

size_t Color::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.Color)
  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 uint32 r = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_r());
    }

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

    // optional uint32 b = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_b());
    }

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

void Color::MergeFrom(const Color& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.Color)
  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) {
      r_ = from.r_;
    }
    if (cached_has_bits & 0x00000002u) {
      g_ = from.g_;
    }
    if (cached_has_bits & 0x00000004u) {
      b_ = from.b_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

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

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


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

void DebugText::InitAsDefaultInstance() {
  ::SC2APIProtocol::_DebugText_default_instance_._instance.get_mutable()->color_ = const_cast< ::SC2APIProtocol::Color*>(
      ::SC2APIProtocol::Color::internal_default_instance());
  ::SC2APIProtocol::_DebugText_default_instance_._instance.get_mutable()->virtual_pos_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
  ::SC2APIProtocol::_DebugText_default_instance_._instance.get_mutable()->world_pos_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
}
class DebugText::_Internal {
 public:
  using HasBits = decltype(std::declval<DebugText>()._has_bits_);
  static const ::SC2APIProtocol::Color& color(const DebugText* msg);
  static void set_has_color(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_text(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Point& virtual_pos(const DebugText* msg);
  static void set_has_virtual_pos(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::Point& world_pos(const DebugText* msg);
  static void set_has_world_pos(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

const ::SC2APIProtocol::Color&
DebugText::_Internal::color(const DebugText* msg) {
  return *msg->color_;
}
const ::SC2APIProtocol::Point&
DebugText::_Internal::virtual_pos(const DebugText* msg) {
  return *msg->virtual_pos_;
}
const ::SC2APIProtocol::Point&
DebugText::_Internal::world_pos(const DebugText* msg) {
  return *msg->world_pos_;
}
void DebugText::clear_virtual_pos() {
  if (virtual_pos_ != nullptr) virtual_pos_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
void DebugText::clear_world_pos() {
  if (world_pos_ != nullptr) world_pos_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
DebugText::DebugText()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugText)
}
DebugText::DebugText(const DebugText& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_text()) {
    text_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.text_);
  }
  if (from._internal_has_color()) {
    color_ = new ::SC2APIProtocol::Color(*from.color_);
  } else {
    color_ = nullptr;
  }
  if (from._internal_has_virtual_pos()) {
    virtual_pos_ = new ::SC2APIProtocol::Point(*from.virtual_pos_);
  } else {
    virtual_pos_ = nullptr;
  }
  if (from._internal_has_world_pos()) {
    world_pos_ = new ::SC2APIProtocol::Point(*from.world_pos_);
  } else {
    world_pos_ = nullptr;
  }
  size_ = from.size_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugText)
}

void DebugText::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugText_s2clientprotocol_2fdebug_2eproto.base);
  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&color_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&size_) -
      reinterpret_cast<char*>(&color_)) + sizeof(size_));
}

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

void DebugText::SharedDtor() {
  text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete color_;
  if (this != internal_default_instance()) delete virtual_pos_;
  if (this != internal_default_instance()) delete world_pos_;
}

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


void DebugText::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.DebugText)
  ::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) {
    if (cached_has_bits & 0x00000001u) {
      text_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(color_ != nullptr);
      color_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(virtual_pos_ != nullptr);
      virtual_pos_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(world_pos_ != nullptr);
      world_pos_->Clear();
    }
  }
  size_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugText::_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.Color color = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_color(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string text = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_text();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "SC2APIProtocol.DebugText.text");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point virtual_pos = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_virtual_pos(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point world_pos = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_world_pos(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 size = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_size(&has_bits);
          size_ = ::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* DebugText::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugText)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.Color color = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::color(this), target, stream);
  }

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

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

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

  // optional uint32 size = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_size(), 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.DebugText)
  return target;
}

size_t DebugText::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugText)
  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 text = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_text());
    }

    // optional .SC2APIProtocol.Color color = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color_);
    }

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

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

    // optional uint32 size = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_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 DebugText::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.DebugText)
  GOOGLE_DCHECK_NE(&from, this);
  const DebugText* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DebugText>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.DebugText)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.DebugText)
    MergeFrom(*source);
  }
}

void DebugText::MergeFrom(const DebugText& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugText)
  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;
      text_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.text_);
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_color()->::SC2APIProtocol::Color::MergeFrom(from._internal_color());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_virtual_pos()->::SC2APIProtocol::Point::MergeFrom(from._internal_virtual_pos());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_world_pos()->::SC2APIProtocol::Point::MergeFrom(from._internal_world_pos());
    }
    if (cached_has_bits & 0x00000010u) {
      size_ = from.size_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void DebugText::InternalSwap(DebugText* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  text_.Swap(&other->text_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(color_, other->color_);
  swap(virtual_pos_, other->virtual_pos_);
  swap(world_pos_, other->world_pos_);
  swap(size_, other->size_);
}

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


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

void DebugLine::InitAsDefaultInstance() {
  ::SC2APIProtocol::_DebugLine_default_instance_._instance.get_mutable()->color_ = const_cast< ::SC2APIProtocol::Color*>(
      ::SC2APIProtocol::Color::internal_default_instance());
  ::SC2APIProtocol::_DebugLine_default_instance_._instance.get_mutable()->line_ = const_cast< ::SC2APIProtocol::Line*>(
      ::SC2APIProtocol::Line::internal_default_instance());
}
class DebugLine::_Internal {
 public:
  using HasBits = decltype(std::declval<DebugLine>()._has_bits_);
  static const ::SC2APIProtocol::Color& color(const DebugLine* msg);
  static void set_has_color(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Line& line(const DebugLine* msg);
  static void set_has_line(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::Color&
DebugLine::_Internal::color(const DebugLine* msg) {
  return *msg->color_;
}
const ::SC2APIProtocol::Line&
DebugLine::_Internal::line(const DebugLine* msg) {
  return *msg->line_;
}
DebugLine::DebugLine()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugLine)
}
DebugLine::DebugLine(const DebugLine& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_color()) {
    color_ = new ::SC2APIProtocol::Color(*from.color_);
  } else {
    color_ = nullptr;
  }
  if (from._internal_has_line()) {
    line_ = new ::SC2APIProtocol::Line(*from.line_);
  } else {
    line_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugLine)
}

void DebugLine::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugLine_s2clientprotocol_2fdebug_2eproto.base);
  ::memset(&color_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&line_) -
      reinterpret_cast<char*>(&color_)) + sizeof(line_));
}

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

void DebugLine::SharedDtor() {
  if (this != internal_default_instance()) delete color_;
  if (this != internal_default_instance()) delete line_;
}

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


void DebugLine::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.DebugLine)
  ::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(color_ != nullptr);
      color_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(line_ != nullptr);
      line_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugLine::_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.Color color = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_color(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Line line = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_line(), 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* DebugLine::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugLine)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .SC2APIProtocol.Line line = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::line(this), 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.DebugLine)
  return target;
}

size_t DebugLine::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugLine)
  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.Color color = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color_);
    }

    // optional .SC2APIProtocol.Line line = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *line_);
    }

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

void DebugLine::MergeFrom(const DebugLine& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugLine)
  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_color()->::SC2APIProtocol::Color::MergeFrom(from._internal_color());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_line()->::SC2APIProtocol::Line::MergeFrom(from._internal_line());
    }
  }
}

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

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

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

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

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


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

void DebugBox::InitAsDefaultInstance() {
  ::SC2APIProtocol::_DebugBox_default_instance_._instance.get_mutable()->color_ = const_cast< ::SC2APIProtocol::Color*>(
      ::SC2APIProtocol::Color::internal_default_instance());
  ::SC2APIProtocol::_DebugBox_default_instance_._instance.get_mutable()->min_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
  ::SC2APIProtocol::_DebugBox_default_instance_._instance.get_mutable()->max_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
}
class DebugBox::_Internal {
 public:
  using HasBits = decltype(std::declval<DebugBox>()._has_bits_);
  static const ::SC2APIProtocol::Color& color(const DebugBox* msg);
  static void set_has_color(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Point& min(const DebugBox* msg);
  static void set_has_min(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SC2APIProtocol::Point& max(const DebugBox* msg);
  static void set_has_max(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

const ::SC2APIProtocol::Color&
DebugBox::_Internal::color(const DebugBox* msg) {
  return *msg->color_;
}
const ::SC2APIProtocol::Point&
DebugBox::_Internal::min(const DebugBox* msg) {
  return *msg->min_;
}
const ::SC2APIProtocol::Point&
DebugBox::_Internal::max(const DebugBox* msg) {
  return *msg->max_;
}
void DebugBox::clear_min() {
  if (min_ != nullptr) min_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
void DebugBox::clear_max() {
  if (max_ != nullptr) max_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
DebugBox::DebugBox()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugBox)
}
DebugBox::DebugBox(const DebugBox& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_color()) {
    color_ = new ::SC2APIProtocol::Color(*from.color_);
  } else {
    color_ = nullptr;
  }
  if (from._internal_has_min()) {
    min_ = new ::SC2APIProtocol::Point(*from.min_);
  } else {
    min_ = nullptr;
  }
  if (from._internal_has_max()) {
    max_ = new ::SC2APIProtocol::Point(*from.max_);
  } else {
    max_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugBox)
}

void DebugBox::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugBox_s2clientprotocol_2fdebug_2eproto.base);
  ::memset(&color_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_) -
      reinterpret_cast<char*>(&color_)) + sizeof(max_));
}

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

void DebugBox::SharedDtor() {
  if (this != internal_default_instance()) delete color_;
  if (this != internal_default_instance()) delete min_;
  if (this != internal_default_instance()) delete max_;
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(color_ != nullptr);
      color_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(min_ != nullptr);
      min_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(max_ != nullptr);
      max_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugBox::_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.Color color = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_color(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point min = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_min(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point max = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_max(), 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* DebugBox::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugBox)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional .SC2APIProtocol.Point max = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::max(this), 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.DebugBox)
  return target;
}

size_t DebugBox::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugBox)
  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 .SC2APIProtocol.Color color = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color_);
    }

    // optional .SC2APIProtocol.Point min = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *min_);
    }

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

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

void DebugBox::MergeFrom(const DebugBox& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugBox)
  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) {
      _internal_mutable_color()->::SC2APIProtocol::Color::MergeFrom(from._internal_color());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_min()->::SC2APIProtocol::Point::MergeFrom(from._internal_min());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_max()->::SC2APIProtocol::Point::MergeFrom(from._internal_max());
    }
  }
}

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

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

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

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

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


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

void DebugSphere::InitAsDefaultInstance() {
  ::SC2APIProtocol::_DebugSphere_default_instance_._instance.get_mutable()->color_ = const_cast< ::SC2APIProtocol::Color*>(
      ::SC2APIProtocol::Color::internal_default_instance());
  ::SC2APIProtocol::_DebugSphere_default_instance_._instance.get_mutable()->p_ = const_cast< ::SC2APIProtocol::Point*>(
      ::SC2APIProtocol::Point::internal_default_instance());
}
class DebugSphere::_Internal {
 public:
  using HasBits = decltype(std::declval<DebugSphere>()._has_bits_);
  static const ::SC2APIProtocol::Color& color(const DebugSphere* msg);
  static void set_has_color(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::Point& p(const DebugSphere* msg);
  static void set_has_p(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_r(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

const ::SC2APIProtocol::Color&
DebugSphere::_Internal::color(const DebugSphere* msg) {
  return *msg->color_;
}
const ::SC2APIProtocol::Point&
DebugSphere::_Internal::p(const DebugSphere* msg) {
  return *msg->p_;
}
void DebugSphere::clear_p() {
  if (p_ != nullptr) p_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
DebugSphere::DebugSphere()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugSphere)
}
DebugSphere::DebugSphere(const DebugSphere& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_color()) {
    color_ = new ::SC2APIProtocol::Color(*from.color_);
  } else {
    color_ = nullptr;
  }
  if (from._internal_has_p()) {
    p_ = new ::SC2APIProtocol::Point(*from.p_);
  } else {
    p_ = nullptr;
  }
  r_ = from.r_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugSphere)
}

void DebugSphere::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugSphere_s2clientprotocol_2fdebug_2eproto.base);
  ::memset(&color_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&r_) -
      reinterpret_cast<char*>(&color_)) + sizeof(r_));
}

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

void DebugSphere::SharedDtor() {
  if (this != internal_default_instance()) delete color_;
  if (this != internal_default_instance()) delete p_;
}

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


void DebugSphere::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.DebugSphere)
  ::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(color_ != nullptr);
      color_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(p_ != nullptr);
      p_->Clear();
    }
  }
  r_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugSphere::_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.Color color = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_color(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point p = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_p(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float r = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_r(&has_bits);
          r_ = ::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* DebugSphere::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugSphere)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional float r = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_r(), 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.DebugSphere)
  return target;
}

size_t DebugSphere::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugSphere)
  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 .SC2APIProtocol.Color color = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *color_);
    }

    // optional .SC2APIProtocol.Point p = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *p_);
    }

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

void DebugSphere::MergeFrom(const DebugSphere& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugSphere)
  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) {
      _internal_mutable_color()->::SC2APIProtocol::Color::MergeFrom(from._internal_color());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_p()->::SC2APIProtocol::Point::MergeFrom(from._internal_p());
    }
    if (cached_has_bits & 0x00000004u) {
      r_ = from.r_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

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

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


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

void DebugCreateUnit::InitAsDefaultInstance() {
  ::SC2APIProtocol::_DebugCreateUnit_default_instance_._instance.get_mutable()->pos_ = const_cast< ::SC2APIProtocol::Point2D*>(
      ::SC2APIProtocol::Point2D::internal_default_instance());
}
class DebugCreateUnit::_Internal {
 public:
  using HasBits = decltype(std::declval<DebugCreateUnit>()._has_bits_);
  static void set_has_unit_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_owner(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::Point2D& pos(const DebugCreateUnit* msg);
  static void set_has_pos(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_quantity(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::SC2APIProtocol::Point2D&
DebugCreateUnit::_Internal::pos(const DebugCreateUnit* msg) {
  return *msg->pos_;
}
void DebugCreateUnit::clear_pos() {
  if (pos_ != nullptr) pos_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
DebugCreateUnit::DebugCreateUnit()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugCreateUnit)
}
DebugCreateUnit::DebugCreateUnit(const DebugCreateUnit& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_pos()) {
    pos_ = new ::SC2APIProtocol::Point2D(*from.pos_);
  } else {
    pos_ = nullptr;
  }
  ::memcpy(&unit_type_, &from.unit_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&quantity_) -
    reinterpret_cast<char*>(&unit_type_)) + sizeof(quantity_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugCreateUnit)
}

void DebugCreateUnit::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DebugCreateUnit_s2clientprotocol_2fdebug_2eproto.base);
  ::memset(&pos_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&quantity_) -
      reinterpret_cast<char*>(&pos_)) + sizeof(quantity_));
}

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

void DebugCreateUnit::SharedDtor() {
  if (this != internal_default_instance()) delete pos_;
}

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


void DebugCreateUnit::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.DebugCreateUnit)
  ::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(pos_ != nullptr);
    pos_->Clear();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&unit_type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&quantity_) -
        reinterpret_cast<char*>(&unit_type_)) + sizeof(quantity_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugCreateUnit::_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 unit_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_unit_type(&has_bits);
          unit_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 owner = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_owner(&has_bits);
          owner_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Point2D pos = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_pos(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 quantity = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_quantity(&has_bits);
          quantity_ = ::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* DebugCreateUnit::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugCreateUnit)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  // optional uint32 quantity = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_quantity(), 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.DebugCreateUnit)
  return target;
}

size_t DebugCreateUnit::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugCreateUnit)
  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.Point2D pos = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *pos_);
    }

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

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

    // optional uint32 quantity = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_quantity());
    }

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

void DebugCreateUnit::MergeFrom(const DebugCreateUnit& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugCreateUnit)
  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_pos()->::SC2APIProtocol::Point2D::MergeFrom(from._internal_pos());
    }
    if (cached_has_bits & 0x00000002u) {
      unit_type_ = from.unit_type_;
    }
    if (cached_has_bits & 0x00000004u) {
      owner_ = from.owner_;
    }
    if (cached_has_bits & 0x00000008u) {
      quantity_ = from.quantity_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

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

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


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

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

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

void DebugKillUnit::SharedCtor() {
}

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

void DebugKillUnit::SharedDtor() {
}

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


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

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

const char* DebugKillUnit::_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 tag = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_tag(::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_tag(), 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* DebugKillUnit::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugKillUnit)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated uint64 tag = 1;
  for (int i = 0, n = this->_internal_tag_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_tag(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.DebugKillUnit)
  return target;
}

size_t DebugKillUnit::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugKillUnit)
  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 tag = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt64Size(this->tag_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_tag_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 DebugKillUnit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.DebugKillUnit)
  GOOGLE_DCHECK_NE(&from, this);
  const DebugKillUnit* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DebugKillUnit>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.DebugKillUnit)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.DebugKillUnit)
    MergeFrom(*source);
  }
}

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

  tag_.MergeFrom(from.tag_);
}

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

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

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

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

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


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

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

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

void DebugTestProcess::SharedCtor() {
  delay_ms_ = 0;
  test_ = 1;
}

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

void DebugTestProcess::SharedDtor() {
}

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


void DebugTestProcess::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.DebugTestProcess)
  ::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) {
    delay_ms_ = 0;
    test_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugTestProcess::_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.DebugTestProcess.Test test = 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::DebugTestProcess_Test_IsValid(val))) {
            _internal_set_test(static_cast<::SC2APIProtocol::DebugTestProcess_Test>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int32 delay_ms = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_delay_ms(&has_bits);
          delay_ms_ = ::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* DebugTestProcess::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugTestProcess)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.DebugTestProcess.Test test = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_test(), target);
  }

  // optional int32 delay_ms = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_delay_ms(), 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.DebugTestProcess)
  return target;
}

size_t DebugTestProcess::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugTestProcess)
  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 delay_ms = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_delay_ms());
    }

    // optional .SC2APIProtocol.DebugTestProcess.Test test = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_test());
    }

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

void DebugTestProcess::MergeFrom(const DebugTestProcess& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugTestProcess)
  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) {
      delay_ms_ = from.delay_ms_;
    }
    if (cached_has_bits & 0x00000002u) {
      test_ = from.test_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

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

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


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

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

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

void DebugSetScore::SharedCtor() {
  score_ = 0;
}

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

void DebugSetScore::SharedDtor() {
}

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


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

  score_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugSetScore::_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 score = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_score(&has_bits);
          score_ = ::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* DebugSetScore::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugSetScore)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float score = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_score(), 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.DebugSetScore)
  return target;
}

size_t DebugSetScore::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugSetScore)
  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 float score = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    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 DebugSetScore::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.DebugSetScore)
  GOOGLE_DCHECK_NE(&from, this);
  const DebugSetScore* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DebugSetScore>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.DebugSetScore)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.DebugSetScore)
    MergeFrom(*source);
  }
}

void DebugSetScore::MergeFrom(const DebugSetScore& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugSetScore)
  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_score()) {
    _internal_set_score(from._internal_score());
  }
}

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

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

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

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

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


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

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

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

void DebugEndGame::SharedCtor() {
  end_result_ = 1;
}

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

void DebugEndGame::SharedDtor() {
}

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


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

  end_result_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugEndGame::_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.DebugEndGame.EndResult end_result = 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::DebugEndGame_EndResult_IsValid(val))) {
            _internal_set_end_result(static_cast<::SC2APIProtocol::DebugEndGame_EndResult>(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* DebugEndGame::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugEndGame)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.DebugEndGame.EndResult end_result = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_end_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.DebugEndGame)
  return target;
}

size_t DebugEndGame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugEndGame)
  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.DebugEndGame.EndResult end_result = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_end_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 DebugEndGame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.DebugEndGame)
  GOOGLE_DCHECK_NE(&from, this);
  const DebugEndGame* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DebugEndGame>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.DebugEndGame)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.DebugEndGame)
    MergeFrom(*source);
  }
}

void DebugEndGame::MergeFrom(const DebugEndGame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugEndGame)
  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_end_result()) {
    _internal_set_end_result(from._internal_end_result());
  }
}

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

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

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

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

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


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

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

DebugSetUnitValue::DebugSetUnitValue()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.DebugSetUnitValue)
}
DebugSetUnitValue::DebugSetUnitValue(const DebugSetUnitValue& 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*>(&unit_value_) -
    reinterpret_cast<char*>(&unit_tag_)) + sizeof(unit_value_));
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.DebugSetUnitValue)
}

void DebugSetUnitValue::SharedCtor() {
  ::memset(&unit_tag_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&value_) -
      reinterpret_cast<char*>(&unit_tag_)) + sizeof(value_));
  unit_value_ = 1;
}

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

void DebugSetUnitValue::SharedDtor() {
}

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


void DebugSetUnitValue::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.DebugSetUnitValue)
  ::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*>(&value_) -
        reinterpret_cast<char*>(&unit_tag_)) + sizeof(value_));
    unit_value_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* DebugSetUnitValue::_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.DebugSetUnitValue.UnitValue unit_value = 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::DebugSetUnitValue_UnitValue_IsValid(val))) {
            _internal_set_unit_value(static_cast<::SC2APIProtocol::DebugSetUnitValue_UnitValue>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional float value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_value(&has_bits);
          value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional uint64 unit_tag = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_unit_tag(&has_bits);
          unit_tag_ = ::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* DebugSetUnitValue::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.DebugSetUnitValue)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.DebugSetUnitValue.UnitValue unit_value = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_unit_value(), target);
  }

  // optional float value = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_value(), target);
  }

  // optional uint64 unit_tag = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->_internal_unit_tag(), 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.DebugSetUnitValue)
  return target;
}

size_t DebugSetUnitValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.DebugSetUnitValue)
  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 = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_unit_tag());
    }

    // optional float value = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 4;
    }

    // optional .SC2APIProtocol.DebugSetUnitValue.UnitValue unit_value = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_unit_value());
    }

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

void DebugSetUnitValue::MergeFrom(const DebugSetUnitValue& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.DebugSetUnitValue)
  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) {
      value_ = from.value_;
    }
    if (cached_has_bits & 0x00000004u) {
      unit_value_ = from.unit_value_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void DebugSetUnitValue::InternalSwap(DebugSetUnitValue* 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(value_, other->value_);
  swap(unit_value_, other->unit_value_);
}

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace SC2APIProtocol
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugCommand* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugCommand >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugCommand >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugDraw* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugDraw >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugDraw >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Line* Arena::CreateMaybeMessage< ::SC2APIProtocol::Line >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Line >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Color* Arena::CreateMaybeMessage< ::SC2APIProtocol::Color >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Color >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugText* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugText >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugText >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugLine* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugLine >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugLine >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugBox* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugBox >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugBox >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugSphere* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugSphere >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugSphere >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugCreateUnit* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugCreateUnit >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugCreateUnit >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugKillUnit* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugKillUnit >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugKillUnit >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugTestProcess* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugTestProcess >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugTestProcess >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugSetScore* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugSetScore >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugSetScore >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugEndGame* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugEndGame >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugEndGame >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::DebugSetUnitValue* Arena::CreateMaybeMessage< ::SC2APIProtocol::DebugSetUnitValue >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::DebugSetUnitValue >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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