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

#include "s2clientprotocol/common.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_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PointI_s2clientprotocol_2fcommon_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Size2DI_s2clientprotocol_2fcommon_2eproto;
namespace SC2APIProtocol {
class AvailableAbilityDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AvailableAbility> _instance;
} _AvailableAbility_default_instance_;
class ImageDataDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ImageData> _instance;
} _ImageData_default_instance_;
class PointIDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PointI> _instance;
} _PointI_default_instance_;
class RectangleIDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RectangleI> _instance;
} _RectangleI_default_instance_;
class Point2DDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Point2D> _instance;
} _Point2D_default_instance_;
class PointDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Point> _instance;
} _Point_default_instance_;
class Size2DIDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Size2DI> _instance;
} _Size2DI_default_instance_;
}  // namespace SC2APIProtocol
static void InitDefaultsscc_info_AvailableAbility_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_ImageData_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_Point_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_Point2D_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_PointI_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_RectangleI_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RectangleI_s2clientprotocol_2fcommon_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_RectangleI_s2clientprotocol_2fcommon_2eproto}, {
      &scc_info_PointI_s2clientprotocol_2fcommon_2eproto.base,}};

static void InitDefaultsscc_info_Size2DI_s2clientprotocol_2fcommon_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_s2clientprotocol_2fcommon_2eproto[7];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_s2clientprotocol_2fcommon_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_s2clientprotocol_2fcommon_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_s2clientprotocol_2fcommon_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::AvailableAbility, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::AvailableAbility, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::AvailableAbility, ability_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::AvailableAbility, requires_point_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ImageData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ImageData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ImageData, bits_per_pixel_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ImageData, size_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ImageData, data_),
  2,
  1,
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PointI, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PointI, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PointI, x_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::PointI, y_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RectangleI, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RectangleI, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RectangleI, p0_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::RectangleI, p1_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point2D, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point2D, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point2D, x_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point2D, y_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point, x_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point, y_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Point, z_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Size2DI, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Size2DI, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Size2DI, x_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::Size2DI, y_),
  0,
  1,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 7, sizeof(::SC2APIProtocol::AvailableAbility)},
  { 9, 17, sizeof(::SC2APIProtocol::ImageData)},
  { 20, 27, sizeof(::SC2APIProtocol::PointI)},
  { 29, 36, sizeof(::SC2APIProtocol::RectangleI)},
  { 38, 45, sizeof(::SC2APIProtocol::Point2D)},
  { 47, 55, sizeof(::SC2APIProtocol::Point)},
  { 58, 65, sizeof(::SC2APIProtocol::Size2DI)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_AvailableAbility_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ImageData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_PointI_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_RectangleI_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Point2D_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Point_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_Size2DI_default_instance_),
};

const char descriptor_table_protodef_s2clientprotocol_2fcommon_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\035s2clientprotocol/common.proto\022\016SC2APIP"
  "rotocol\">\n\020AvailableAbility\022\022\n\nability_i"
  "d\030\001 \001(\005\022\026\n\016requires_point\030\002 \001(\010\"X\n\tImage"
  "Data\022\026\n\016bits_per_pixel\030\001 \001(\005\022%\n\004size\030\002 \001"
  "(\0132\027.SC2APIProtocol.Size2DI\022\014\n\004data\030\003 \001("
  "\014\"\036\n\006PointI\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005\"T\n\nRec"
  "tangleI\022\"\n\002p0\030\001 \001(\0132\026.SC2APIProtocol.Poi"
  "ntI\022\"\n\002p1\030\002 \001(\0132\026.SC2APIProtocol.PointI\""
  "\037\n\007Point2D\022\t\n\001x\030\001 \001(\002\022\t\n\001y\030\002 \001(\002\"(\n\005Poin"
  "t\022\t\n\001x\030\001 \001(\002\022\t\n\001y\030\002 \001(\002\022\t\n\001z\030\003 \001(\002\"\037\n\007Si"
  "ze2DI\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005*A\n\004Race\022\n\n\006N"
  "oRace\020\000\022\n\n\006Terran\020\001\022\010\n\004Zerg\020\002\022\013\n\007Protoss"
  "\020\003\022\n\n\006Random\020\004"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_s2clientprotocol_2fcommon_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_s2clientprotocol_2fcommon_2eproto_sccs[7] = {
  &scc_info_AvailableAbility_s2clientprotocol_2fcommon_2eproto.base,
  &scc_info_ImageData_s2clientprotocol_2fcommon_2eproto.base,
  &scc_info_Point_s2clientprotocol_2fcommon_2eproto.base,
  &scc_info_Point2D_s2clientprotocol_2fcommon_2eproto.base,
  &scc_info_PointI_s2clientprotocol_2fcommon_2eproto.base,
  &scc_info_RectangleI_s2clientprotocol_2fcommon_2eproto.base,
  &scc_info_Size2DI_s2clientprotocol_2fcommon_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_s2clientprotocol_2fcommon_2eproto_once;
static bool descriptor_table_s2clientprotocol_2fcommon_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_s2clientprotocol_2fcommon_2eproto = {
  &descriptor_table_s2clientprotocol_2fcommon_2eproto_initialized, descriptor_table_protodef_s2clientprotocol_2fcommon_2eproto, "s2clientprotocol/common.proto", 494,
  &descriptor_table_s2clientprotocol_2fcommon_2eproto_once, descriptor_table_s2clientprotocol_2fcommon_2eproto_sccs, descriptor_table_s2clientprotocol_2fcommon_2eproto_deps, 7, 0,
  schemas, file_default_instances, TableStruct_s2clientprotocol_2fcommon_2eproto::offsets,
  file_level_metadata_s2clientprotocol_2fcommon_2eproto, 7, file_level_enum_descriptors_s2clientprotocol_2fcommon_2eproto, file_level_service_descriptors_s2clientprotocol_2fcommon_2eproto,
};

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


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

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

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

void AvailableAbility::SharedCtor() {
  ::memset(&ability_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&requires_point_) -
      reinterpret_cast<char*>(&ability_id_)) + sizeof(requires_point_));
}

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

void AvailableAbility::SharedDtor() {
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&ability_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&requires_point_) -
        reinterpret_cast<char*>(&ability_id_)) + sizeof(requires_point_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

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

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

  // optional bool requires_point = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_requires_point(), 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.AvailableAbility)
  return target;
}

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

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

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

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

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

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

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

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

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

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


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

void ImageData::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ImageData_default_instance_._instance.get_mutable()->size_ = const_cast< ::SC2APIProtocol::Size2DI*>(
      ::SC2APIProtocol::Size2DI::internal_default_instance());
}
class ImageData::_Internal {
 public:
  using HasBits = decltype(std::declval<ImageData>()._has_bits_);
  static void set_has_bits_per_pixel(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::Size2DI& size(const ImageData* msg);
  static void set_has_size(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SC2APIProtocol::Size2DI&
ImageData::_Internal::size(const ImageData* msg) {
  return *msg->size_;
}
ImageData::ImageData()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ImageData)
}
ImageData::ImageData(const ImageData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_data()) {
    data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  if (from._internal_has_size()) {
    size_ = new ::SC2APIProtocol::Size2DI(*from.size_);
  } else {
    size_ = nullptr;
  }
  bits_per_pixel_ = from.bits_per_pixel_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ImageData)
}

void ImageData::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ImageData_s2clientprotocol_2fcommon_2eproto.base);
  data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&size_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&bits_per_pixel_) -
      reinterpret_cast<char*>(&size_)) + sizeof(bits_per_pixel_));
}

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

void ImageData::SharedDtor() {
  data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete size_;
}

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


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

const char* ImageData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 bits_per_pixel = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_bits_per_pixel(&has_bits);
          bits_per_pixel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.Size2DI size = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_size(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_data();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

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

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

  // optional bytes data = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_data(), target);
  }

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

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

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

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

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

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

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_size()->::SC2APIProtocol::Size2DI::MergeFrom(from._internal_size());
    }
    if (cached_has_bits & 0x00000004u) {
      bits_per_pixel_ = from.bits_per_pixel_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

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

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


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

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

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

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

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

void PointI::SharedDtor() {
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&x_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&y_) -
        reinterpret_cast<char*>(&x_)) + sizeof(y_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

const ::SC2APIProtocol::PointI&
RectangleI::_Internal::p0(const RectangleI* msg) {
  return *msg->p0_;
}
const ::SC2APIProtocol::PointI&
RectangleI::_Internal::p1(const RectangleI* msg) {
  return *msg->p1_;
}
RectangleI::RectangleI()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.RectangleI)
}
RectangleI::RectangleI(const RectangleI& 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::PointI(*from.p0_);
  } else {
    p0_ = nullptr;
  }
  if (from._internal_has_p1()) {
    p1_ = new ::SC2APIProtocol::PointI(*from.p1_);
  } else {
    p1_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.RectangleI)
}

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

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

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

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


void RectangleI::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.RectangleI)
  ::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* RectangleI::_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.PointI 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.PointI 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* RectangleI::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.RectangleI)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.PointI 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.PointI 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.RectangleI)
  return target;
}

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

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

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

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

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

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

void RectangleI::InternalSwap(RectangleI* 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 RectangleI::GetMetadata() const {
  return GetMetadataStatic();
}


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

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

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

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

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

void Point2D::SharedDtor() {
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&x_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&y_) -
        reinterpret_cast<char*>(&x_)) + sizeof(y_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Point2D::_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 x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_x(&has_bits);
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_y(&has_bits);
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional float x = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

  // optional float y = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), 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.Point2D)
  return target;
}

size_t Point2D::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.Point2D)
  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 float x = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 4;
    }

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

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

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

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

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

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

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

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

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


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

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

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

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

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

void Point::SharedDtor() {
}

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


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

const char* Point::_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 x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_x(&has_bits);
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_y(&has_bits);
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float z = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_z(&has_bits);
          z_ = ::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* Point::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.Point)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float x = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
  }

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

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

size_t Point::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.Point)
  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 float x = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 4;
    }

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

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

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

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

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

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

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

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


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

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

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

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

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

void Size2DI::SharedDtor() {
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&x_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&y_) -
        reinterpret_cast<char*>(&x_)) + sizeof(y_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace SC2APIProtocol
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::AvailableAbility* Arena::CreateMaybeMessage< ::SC2APIProtocol::AvailableAbility >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::AvailableAbility >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ImageData* Arena::CreateMaybeMessage< ::SC2APIProtocol::ImageData >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ImageData >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::PointI* Arena::CreateMaybeMessage< ::SC2APIProtocol::PointI >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::PointI >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::RectangleI* Arena::CreateMaybeMessage< ::SC2APIProtocol::RectangleI >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::RectangleI >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Point2D* Arena::CreateMaybeMessage< ::SC2APIProtocol::Point2D >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Point2D >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Point* Arena::CreateMaybeMessage< ::SC2APIProtocol::Point >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Point >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::Size2DI* Arena::CreateMaybeMessage< ::SC2APIProtocol::Size2DI >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::Size2DI >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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