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

#include "s2clientprotocol/spatial.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_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ActionSpatialCameraMove_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ActionSpatialUnitCommand_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ActionSpatialUnitSelectionPoint_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ActionSpatialUnitSelectionRect_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FeatureLayers_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fspatial_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FeatureLayersMinimap_s2clientprotocol_2fspatial_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_s2clientprotocol_2fcommon_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ImageData_s2clientprotocol_2fcommon_2eproto;
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<1> scc_info_RectangleI_s2clientprotocol_2fcommon_2eproto;
namespace SC2APIProtocol {
class ObservationFeatureLayerDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ObservationFeatureLayer> _instance;
} _ObservationFeatureLayer_default_instance_;
class FeatureLayersDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FeatureLayers> _instance;
} _FeatureLayers_default_instance_;
class FeatureLayersMinimapDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FeatureLayersMinimap> _instance;
} _FeatureLayersMinimap_default_instance_;
class ObservationRenderDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ObservationRender> _instance;
} _ObservationRender_default_instance_;
class ActionSpatialDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionSpatial> _instance;
  const ::SC2APIProtocol::ActionSpatialUnitCommand* unit_command_;
  const ::SC2APIProtocol::ActionSpatialCameraMove* camera_move_;
  const ::SC2APIProtocol::ActionSpatialUnitSelectionPoint* unit_selection_point_;
  const ::SC2APIProtocol::ActionSpatialUnitSelectionRect* unit_selection_rect_;
} _ActionSpatial_default_instance_;
class ActionSpatialUnitCommandDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionSpatialUnitCommand> _instance;
  const ::SC2APIProtocol::PointI* target_screen_coord_;
  const ::SC2APIProtocol::PointI* target_minimap_coord_;
} _ActionSpatialUnitCommand_default_instance_;
class ActionSpatialCameraMoveDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionSpatialCameraMove> _instance;
} _ActionSpatialCameraMove_default_instance_;
class ActionSpatialUnitSelectionPointDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionSpatialUnitSelectionPoint> _instance;
} _ActionSpatialUnitSelectionPoint_default_instance_;
class ActionSpatialUnitSelectionRectDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ActionSpatialUnitSelectionRect> _instance;
} _ActionSpatialUnitSelectionRect_default_instance_;
}  // namespace SC2APIProtocol
static void InitDefaultsscc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto}, {
      &scc_info_ActionSpatialUnitCommand_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_ActionSpatialCameraMove_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_ActionSpatialUnitSelectionPoint_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_ActionSpatialUnitSelectionRect_s2clientprotocol_2fspatial_2eproto.base,}};

static void InitDefaultsscc_info_ActionSpatialCameraMove_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_ActionSpatialUnitCommand_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_ActionSpatialUnitSelectionPoint_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_ActionSpatialUnitSelectionRect_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_FeatureLayers_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_FeatureLayersMinimap_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static void InitDefaultsscc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto}, {
      &scc_info_FeatureLayers_s2clientprotocol_2fspatial_2eproto.base,
      &scc_info_FeatureLayersMinimap_s2clientprotocol_2fspatial_2eproto.base,}};

static void InitDefaultsscc_info_ObservationRender_s2clientprotocol_2fspatial_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

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

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_s2clientprotocol_2fspatial_2eproto[9];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_s2clientprotocol_2fspatial_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_s2clientprotocol_2fspatial_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_s2clientprotocol_2fspatial_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationFeatureLayer, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationFeatureLayer, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationFeatureLayer, renders_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationFeatureLayer, minimap_renders_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, height_map_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, visibility_map_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, creep_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, power_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_type_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, selected_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_hit_points_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_hit_points_ratio_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_energy_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_energy_ratio_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_shields_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_shields_ratio_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, player_relative_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_density_aa_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, unit_density_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, effects_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, hallucinations_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, cloaked_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, blip_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, buffs_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, buff_duration_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, active_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, build_progress_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, buildable_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, pathable_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayers, placeholder_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  13,
  8,
  14,
  9,
  15,
  10,
  11,
  12,
  16,
  17,
  18,
  19,
  20,
  22,
  21,
  23,
  24,
  25,
  26,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, height_map_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, visibility_map_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, creep_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, camera_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, player_id_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, player_relative_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, selected_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, alerts_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, buildable_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, pathable_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::FeatureLayersMinimap, unit_type_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  8,
  9,
  10,
  7,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationRender, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationRender, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationRender, map_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ObservationRender, minimap_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatial, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatial, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatial, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::SC2APIProtocol::ActionSpatialDefaultTypeInternal, unit_command_),
  offsetof(::SC2APIProtocol::ActionSpatialDefaultTypeInternal, camera_move_),
  offsetof(::SC2APIProtocol::ActionSpatialDefaultTypeInternal, unit_selection_point_),
  offsetof(::SC2APIProtocol::ActionSpatialDefaultTypeInternal, unit_selection_rect_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatial, action_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitCommand, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitCommand, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitCommand, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitCommand, ability_id_),
  offsetof(::SC2APIProtocol::ActionSpatialUnitCommandDefaultTypeInternal, target_screen_coord_),
  offsetof(::SC2APIProtocol::ActionSpatialUnitCommandDefaultTypeInternal, target_minimap_coord_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitCommand, queue_command_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitCommand, target_),
  0,
  ~0u,
  ~0u,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialCameraMove, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialCameraMove, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialCameraMove, center_minimap_),
  0,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionPoint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionPoint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionPoint, selection_screen_coord_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionPoint, type_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionRect, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionRect, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionRect, selection_screen_coord_),
  PROTOBUF_FIELD_OFFSET(::SC2APIProtocol::ActionSpatialUnitSelectionRect, selection_add_),
  ~0u,
  0,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 7, sizeof(::SC2APIProtocol::ObservationFeatureLayer)},
  { 9, 41, sizeof(::SC2APIProtocol::FeatureLayers)},
  { 68, 84, sizeof(::SC2APIProtocol::FeatureLayersMinimap)},
  { 95, 102, sizeof(::SC2APIProtocol::ObservationRender)},
  { 104, 114, sizeof(::SC2APIProtocol::ActionSpatial)},
  { 118, 128, sizeof(::SC2APIProtocol::ActionSpatialUnitCommand)},
  { 132, 138, sizeof(::SC2APIProtocol::ActionSpatialCameraMove)},
  { 139, 146, sizeof(::SC2APIProtocol::ActionSpatialUnitSelectionPoint)},
  { 148, 155, sizeof(::SC2APIProtocol::ActionSpatialUnitSelectionRect)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ObservationFeatureLayer_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_FeatureLayers_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_FeatureLayersMinimap_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ObservationRender_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionSpatial_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionSpatialUnitCommand_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionSpatialCameraMove_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionSpatialUnitSelectionPoint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::SC2APIProtocol::_ActionSpatialUnitSelectionRect_default_instance_),
};

const char descriptor_table_protodef_s2clientprotocol_2fspatial_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\036s2clientprotocol/spatial.proto\022\016SC2API"
  "Protocol\032\035s2clientprotocol/common.proto\""
  "\210\001\n\027ObservationFeatureLayer\022.\n\007renders\030\001"
  " \001(\0132\035.SC2APIProtocol.FeatureLayers\022=\n\017m"
  "inimap_renders\030\002 \001(\0132$.SC2APIProtocol.Fe"
  "atureLayersMinimap\"\234\n\n\rFeatureLayers\022-\n\n"
  "height_map\030\001 \001(\0132\031.SC2APIProtocol.ImageD"
  "ata\0221\n\016visibility_map\030\002 \001(\0132\031.SC2APIProt"
  "ocol.ImageData\022(\n\005creep\030\003 \001(\0132\031.SC2APIPr"
  "otocol.ImageData\022(\n\005power\030\004 \001(\0132\031.SC2API"
  "Protocol.ImageData\022,\n\tplayer_id\030\005 \001(\0132\031."
  "SC2APIProtocol.ImageData\022,\n\tunit_type\030\006 "
  "\001(\0132\031.SC2APIProtocol.ImageData\022+\n\010select"
  "ed\030\007 \001(\0132\031.SC2APIProtocol.ImageData\0222\n\017u"
  "nit_hit_points\030\010 \001(\0132\031.SC2APIProtocol.Im"
  "ageData\0228\n\025unit_hit_points_ratio\030\021 \001(\0132\031"
  ".SC2APIProtocol.ImageData\022.\n\013unit_energy"
  "\030\t \001(\0132\031.SC2APIProtocol.ImageData\0224\n\021uni"
  "t_energy_ratio\030\022 \001(\0132\031.SC2APIProtocol.Im"
  "ageData\022/\n\014unit_shields\030\n \001(\0132\031.SC2APIPr"
  "otocol.ImageData\0225\n\022unit_shields_ratio\030\023"
  " \001(\0132\031.SC2APIProtocol.ImageData\0222\n\017playe"
  "r_relative\030\013 \001(\0132\031.SC2APIProtocol.ImageD"
  "ata\0222\n\017unit_density_aa\030\016 \001(\0132\031.SC2APIPro"
  "tocol.ImageData\022/\n\014unit_density\030\017 \001(\0132\031."
  "SC2APIProtocol.ImageData\022*\n\007effects\030\024 \001("
  "\0132\031.SC2APIProtocol.ImageData\0221\n\016hallucin"
  "ations\030\025 \001(\0132\031.SC2APIProtocol.ImageData\022"
  "*\n\007cloaked\030\026 \001(\0132\031.SC2APIProtocol.ImageD"
  "ata\022\'\n\004blip\030\027 \001(\0132\031.SC2APIProtocol.Image"
  "Data\022(\n\005buffs\030\030 \001(\0132\031.SC2APIProtocol.Ima"
  "geData\0220\n\rbuff_duration\030\032 \001(\0132\031.SC2APIPr"
  "otocol.ImageData\022)\n\006active\030\031 \001(\0132\031.SC2AP"
  "IProtocol.ImageData\0221\n\016build_progress\030\033 "
  "\001(\0132\031.SC2APIProtocol.ImageData\022,\n\tbuilda"
  "ble\030\034 \001(\0132\031.SC2APIProtocol.ImageData\022+\n\010"
  "pathable\030\035 \001(\0132\031.SC2APIProtocol.ImageDat"
  "a\022.\n\013placeholder\030\036 \001(\0132\031.SC2APIProtocol."
  "ImageData\"\220\004\n\024FeatureLayersMinimap\022-\n\nhe"
  "ight_map\030\001 \001(\0132\031.SC2APIProtocol.ImageDat"
  "a\0221\n\016visibility_map\030\002 \001(\0132\031.SC2APIProtoc"
  "ol.ImageData\022(\n\005creep\030\003 \001(\0132\031.SC2APIProt"
  "ocol.ImageData\022)\n\006camera\030\004 \001(\0132\031.SC2APIP"
  "rotocol.ImageData\022,\n\tplayer_id\030\005 \001(\0132\031.S"
  "C2APIProtocol.ImageData\0222\n\017player_relati"
  "ve\030\006 \001(\0132\031.SC2APIProtocol.ImageData\022+\n\010s"
  "elected\030\007 \001(\0132\031.SC2APIProtocol.ImageData"
  "\022)\n\006alerts\030\t \001(\0132\031.SC2APIProtocol.ImageD"
  "ata\022,\n\tbuildable\030\n \001(\0132\031.SC2APIProtocol."
  "ImageData\022+\n\010pathable\030\013 \001(\0132\031.SC2APIProt"
  "ocol.ImageData\022,\n\tunit_type\030\010 \001(\0132\031.SC2A"
  "PIProtocol.ImageData\"g\n\021ObservationRende"
  "r\022&\n\003map\030\001 \001(\0132\031.SC2APIProtocol.ImageDat"
  "a\022*\n\007minimap\030\002 \001(\0132\031.SC2APIProtocol.Imag"
  "eData\"\273\002\n\rActionSpatial\022@\n\014unit_command\030"
  "\001 \001(\0132(.SC2APIProtocol.ActionSpatialUnit"
  "CommandH\000\022>\n\013camera_move\030\002 \001(\0132\'.SC2APIP"
  "rotocol.ActionSpatialCameraMoveH\000\022O\n\024uni"
  "t_selection_point\030\003 \001(\0132/.SC2APIProtocol"
  ".ActionSpatialUnitSelectionPointH\000\022M\n\023un"
  "it_selection_rect\030\004 \001(\0132..SC2APIProtocol"
  ".ActionSpatialUnitSelectionRectH\000B\010\n\006act"
  "ion\"\276\001\n\030ActionSpatialUnitCommand\022\022\n\nabil"
  "ity_id\030\001 \001(\005\0225\n\023target_screen_coord\030\002 \001("
  "\0132\026.SC2APIProtocol.PointIH\000\0226\n\024target_mi"
  "nimap_coord\030\003 \001(\0132\026.SC2APIProtocol.Point"
  "IH\000\022\025\n\rqueue_command\030\004 \001(\010B\010\n\006target\"I\n\027"
  "ActionSpatialCameraMove\022.\n\016center_minima"
  "p\030\001 \001(\0132\026.SC2APIProtocol.PointI\"\332\001\n\037Acti"
  "onSpatialUnitSelectionPoint\0226\n\026selection"
  "_screen_coord\030\001 \001(\0132\026.SC2APIProtocol.Poi"
  "ntI\022B\n\004type\030\002 \001(\01624.SC2APIProtocol.Actio"
  "nSpatialUnitSelectionPoint.Type\";\n\004Type\022"
  "\n\n\006Select\020\001\022\n\n\006Toggle\020\002\022\013\n\007AllType\020\003\022\016\n\n"
  "AddAllType\020\004\"s\n\036ActionSpatialUnitSelecti"
  "onRect\022:\n\026selection_screen_coord\030\001 \003(\0132\032"
  ".SC2APIProtocol.RectangleI\022\025\n\rselection_"
  "add\030\002 \001(\010"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_s2clientprotocol_2fspatial_2eproto_deps[1] = {
  &::descriptor_table_s2clientprotocol_2fcommon_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_s2clientprotocol_2fspatial_2eproto_sccs[9] = {
  &scc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_ActionSpatialCameraMove_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_ActionSpatialUnitCommand_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_ActionSpatialUnitSelectionPoint_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_ActionSpatialUnitSelectionRect_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_FeatureLayers_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_FeatureLayersMinimap_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto.base,
  &scc_info_ObservationRender_s2clientprotocol_2fspatial_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_s2clientprotocol_2fspatial_2eproto_once;
static bool descriptor_table_s2clientprotocol_2fspatial_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_s2clientprotocol_2fspatial_2eproto = {
  &descriptor_table_s2clientprotocol_2fspatial_2eproto_initialized, descriptor_table_protodef_s2clientprotocol_2fspatial_2eproto, "s2clientprotocol/spatial.proto", 3089,
  &descriptor_table_s2clientprotocol_2fspatial_2eproto_once, descriptor_table_s2clientprotocol_2fspatial_2eproto_sccs, descriptor_table_s2clientprotocol_2fspatial_2eproto_deps, 9, 1,
  schemas, file_default_instances, TableStruct_s2clientprotocol_2fspatial_2eproto::offsets,
  file_level_metadata_s2clientprotocol_2fspatial_2eproto, 9, file_level_enum_descriptors_s2clientprotocol_2fspatial_2eproto, file_level_service_descriptors_s2clientprotocol_2fspatial_2eproto,
};

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

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ActionSpatialUnitSelectionPoint_Type ActionSpatialUnitSelectionPoint::Select;
constexpr ActionSpatialUnitSelectionPoint_Type ActionSpatialUnitSelectionPoint::Toggle;
constexpr ActionSpatialUnitSelectionPoint_Type ActionSpatialUnitSelectionPoint::AllType;
constexpr ActionSpatialUnitSelectionPoint_Type ActionSpatialUnitSelectionPoint::AddAllType;
constexpr ActionSpatialUnitSelectionPoint_Type ActionSpatialUnitSelectionPoint::Type_MIN;
constexpr ActionSpatialUnitSelectionPoint_Type ActionSpatialUnitSelectionPoint::Type_MAX;
constexpr int ActionSpatialUnitSelectionPoint::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)

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

void ObservationFeatureLayer::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ObservationFeatureLayer_default_instance_._instance.get_mutable()->renders_ = const_cast< ::SC2APIProtocol::FeatureLayers*>(
      ::SC2APIProtocol::FeatureLayers::internal_default_instance());
  ::SC2APIProtocol::_ObservationFeatureLayer_default_instance_._instance.get_mutable()->minimap_renders_ = const_cast< ::SC2APIProtocol::FeatureLayersMinimap*>(
      ::SC2APIProtocol::FeatureLayersMinimap::internal_default_instance());
}
class ObservationFeatureLayer::_Internal {
 public:
  using HasBits = decltype(std::declval<ObservationFeatureLayer>()._has_bits_);
  static const ::SC2APIProtocol::FeatureLayers& renders(const ObservationFeatureLayer* msg);
  static void set_has_renders(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::FeatureLayersMinimap& minimap_renders(const ObservationFeatureLayer* msg);
  static void set_has_minimap_renders(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::FeatureLayers&
ObservationFeatureLayer::_Internal::renders(const ObservationFeatureLayer* msg) {
  return *msg->renders_;
}
const ::SC2APIProtocol::FeatureLayersMinimap&
ObservationFeatureLayer::_Internal::minimap_renders(const ObservationFeatureLayer* msg) {
  return *msg->minimap_renders_;
}
ObservationFeatureLayer::ObservationFeatureLayer()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ObservationFeatureLayer)
}
ObservationFeatureLayer::ObservationFeatureLayer(const ObservationFeatureLayer& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_renders()) {
    renders_ = new ::SC2APIProtocol::FeatureLayers(*from.renders_);
  } else {
    renders_ = nullptr;
  }
  if (from._internal_has_minimap_renders()) {
    minimap_renders_ = new ::SC2APIProtocol::FeatureLayersMinimap(*from.minimap_renders_);
  } else {
    minimap_renders_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ObservationFeatureLayer)
}

void ObservationFeatureLayer::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ObservationFeatureLayer_s2clientprotocol_2fspatial_2eproto.base);
  ::memset(&renders_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&minimap_renders_) -
      reinterpret_cast<char*>(&renders_)) + sizeof(minimap_renders_));
}

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

void ObservationFeatureLayer::SharedDtor() {
  if (this != internal_default_instance()) delete renders_;
  if (this != internal_default_instance()) delete minimap_renders_;
}

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


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

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

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

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

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

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

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

void ObservationFeatureLayer::MergeFrom(const ObservationFeatureLayer& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ObservationFeatureLayer)
  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_renders()->::SC2APIProtocol::FeatureLayers::MergeFrom(from._internal_renders());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_minimap_renders()->::SC2APIProtocol::FeatureLayersMinimap::MergeFrom(from._internal_minimap_renders());
    }
  }
}

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

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

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

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

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


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

void FeatureLayers::InitAsDefaultInstance() {
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->height_map_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->visibility_map_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->creep_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->power_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->player_id_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_type_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->selected_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_hit_points_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_hit_points_ratio_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_energy_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_energy_ratio_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_shields_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_shields_ratio_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->player_relative_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_density_aa_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->unit_density_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->effects_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->hallucinations_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->cloaked_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->blip_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->buffs_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->buff_duration_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->active_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->build_progress_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->buildable_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->pathable_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayers_default_instance_._instance.get_mutable()->placeholder_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
}
class FeatureLayers::_Internal {
 public:
  using HasBits = decltype(std::declval<FeatureLayers>()._has_bits_);
  static const ::SC2APIProtocol::ImageData& height_map(const FeatureLayers* msg);
  static void set_has_height_map(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::ImageData& visibility_map(const FeatureLayers* msg);
  static void set_has_visibility_map(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SC2APIProtocol::ImageData& creep(const FeatureLayers* msg);
  static void set_has_creep(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::ImageData& power(const FeatureLayers* msg);
  static void set_has_power(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SC2APIProtocol::ImageData& player_id(const FeatureLayers* msg);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::SC2APIProtocol::ImageData& unit_type(const FeatureLayers* msg);
  static void set_has_unit_type(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::SC2APIProtocol::ImageData& selected(const FeatureLayers* msg);
  static void set_has_selected(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::SC2APIProtocol::ImageData& unit_hit_points(const FeatureLayers* msg);
  static void set_has_unit_hit_points(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static const ::SC2APIProtocol::ImageData& unit_hit_points_ratio(const FeatureLayers* msg);
  static void set_has_unit_hit_points_ratio(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static const ::SC2APIProtocol::ImageData& unit_energy(const FeatureLayers* msg);
  static void set_has_unit_energy(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static const ::SC2APIProtocol::ImageData& unit_energy_ratio(const FeatureLayers* msg);
  static void set_has_unit_energy_ratio(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static const ::SC2APIProtocol::ImageData& unit_shields(const FeatureLayers* msg);
  static void set_has_unit_shields(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static const ::SC2APIProtocol::ImageData& unit_shields_ratio(const FeatureLayers* msg);
  static void set_has_unit_shields_ratio(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static const ::SC2APIProtocol::ImageData& player_relative(const FeatureLayers* msg);
  static void set_has_player_relative(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static const ::SC2APIProtocol::ImageData& unit_density_aa(const FeatureLayers* msg);
  static void set_has_unit_density_aa(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static const ::SC2APIProtocol::ImageData& unit_density(const FeatureLayers* msg);
  static void set_has_unit_density(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static const ::SC2APIProtocol::ImageData& effects(const FeatureLayers* msg);
  static void set_has_effects(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static const ::SC2APIProtocol::ImageData& hallucinations(const FeatureLayers* msg);
  static void set_has_hallucinations(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
  static const ::SC2APIProtocol::ImageData& cloaked(const FeatureLayers* msg);
  static void set_has_cloaked(HasBits* has_bits) {
    (*has_bits)[0] |= 262144u;
  }
  static const ::SC2APIProtocol::ImageData& blip(const FeatureLayers* msg);
  static void set_has_blip(HasBits* has_bits) {
    (*has_bits)[0] |= 524288u;
  }
  static const ::SC2APIProtocol::ImageData& buffs(const FeatureLayers* msg);
  static void set_has_buffs(HasBits* has_bits) {
    (*has_bits)[0] |= 1048576u;
  }
  static const ::SC2APIProtocol::ImageData& buff_duration(const FeatureLayers* msg);
  static void set_has_buff_duration(HasBits* has_bits) {
    (*has_bits)[0] |= 4194304u;
  }
  static const ::SC2APIProtocol::ImageData& active(const FeatureLayers* msg);
  static void set_has_active(HasBits* has_bits) {
    (*has_bits)[0] |= 2097152u;
  }
  static const ::SC2APIProtocol::ImageData& build_progress(const FeatureLayers* msg);
  static void set_has_build_progress(HasBits* has_bits) {
    (*has_bits)[0] |= 8388608u;
  }
  static const ::SC2APIProtocol::ImageData& buildable(const FeatureLayers* msg);
  static void set_has_buildable(HasBits* has_bits) {
    (*has_bits)[0] |= 16777216u;
  }
  static const ::SC2APIProtocol::ImageData& pathable(const FeatureLayers* msg);
  static void set_has_pathable(HasBits* has_bits) {
    (*has_bits)[0] |= 33554432u;
  }
  static const ::SC2APIProtocol::ImageData& placeholder(const FeatureLayers* msg);
  static void set_has_placeholder(HasBits* has_bits) {
    (*has_bits)[0] |= 67108864u;
  }
};

const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::height_map(const FeatureLayers* msg) {
  return *msg->height_map_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::visibility_map(const FeatureLayers* msg) {
  return *msg->visibility_map_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::creep(const FeatureLayers* msg) {
  return *msg->creep_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::power(const FeatureLayers* msg) {
  return *msg->power_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::player_id(const FeatureLayers* msg) {
  return *msg->player_id_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_type(const FeatureLayers* msg) {
  return *msg->unit_type_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::selected(const FeatureLayers* msg) {
  return *msg->selected_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_hit_points(const FeatureLayers* msg) {
  return *msg->unit_hit_points_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_hit_points_ratio(const FeatureLayers* msg) {
  return *msg->unit_hit_points_ratio_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_energy(const FeatureLayers* msg) {
  return *msg->unit_energy_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_energy_ratio(const FeatureLayers* msg) {
  return *msg->unit_energy_ratio_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_shields(const FeatureLayers* msg) {
  return *msg->unit_shields_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_shields_ratio(const FeatureLayers* msg) {
  return *msg->unit_shields_ratio_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::player_relative(const FeatureLayers* msg) {
  return *msg->player_relative_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_density_aa(const FeatureLayers* msg) {
  return *msg->unit_density_aa_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::unit_density(const FeatureLayers* msg) {
  return *msg->unit_density_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::effects(const FeatureLayers* msg) {
  return *msg->effects_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::hallucinations(const FeatureLayers* msg) {
  return *msg->hallucinations_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::cloaked(const FeatureLayers* msg) {
  return *msg->cloaked_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::blip(const FeatureLayers* msg) {
  return *msg->blip_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::buffs(const FeatureLayers* msg) {
  return *msg->buffs_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::buff_duration(const FeatureLayers* msg) {
  return *msg->buff_duration_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::active(const FeatureLayers* msg) {
  return *msg->active_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::build_progress(const FeatureLayers* msg) {
  return *msg->build_progress_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::buildable(const FeatureLayers* msg) {
  return *msg->buildable_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::pathable(const FeatureLayers* msg) {
  return *msg->pathable_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayers::_Internal::placeholder(const FeatureLayers* msg) {
  return *msg->placeholder_;
}
void FeatureLayers::clear_height_map() {
  if (height_map_ != nullptr) height_map_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void FeatureLayers::clear_visibility_map() {
  if (visibility_map_ != nullptr) visibility_map_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
void FeatureLayers::clear_creep() {
  if (creep_ != nullptr) creep_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
void FeatureLayers::clear_power() {
  if (power_ != nullptr) power_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
void FeatureLayers::clear_player_id() {
  if (player_id_ != nullptr) player_id_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
void FeatureLayers::clear_unit_type() {
  if (unit_type_ != nullptr) unit_type_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
void FeatureLayers::clear_selected() {
  if (selected_ != nullptr) selected_->Clear();
  _has_bits_[0] &= ~0x00000040u;
}
void FeatureLayers::clear_unit_hit_points() {
  if (unit_hit_points_ != nullptr) unit_hit_points_->Clear();
  _has_bits_[0] &= ~0x00000080u;
}
void FeatureLayers::clear_unit_hit_points_ratio() {
  if (unit_hit_points_ratio_ != nullptr) unit_hit_points_ratio_->Clear();
  _has_bits_[0] &= ~0x00002000u;
}
void FeatureLayers::clear_unit_energy() {
  if (unit_energy_ != nullptr) unit_energy_->Clear();
  _has_bits_[0] &= ~0x00000100u;
}
void FeatureLayers::clear_unit_energy_ratio() {
  if (unit_energy_ratio_ != nullptr) unit_energy_ratio_->Clear();
  _has_bits_[0] &= ~0x00004000u;
}
void FeatureLayers::clear_unit_shields() {
  if (unit_shields_ != nullptr) unit_shields_->Clear();
  _has_bits_[0] &= ~0x00000200u;
}
void FeatureLayers::clear_unit_shields_ratio() {
  if (unit_shields_ratio_ != nullptr) unit_shields_ratio_->Clear();
  _has_bits_[0] &= ~0x00008000u;
}
void FeatureLayers::clear_player_relative() {
  if (player_relative_ != nullptr) player_relative_->Clear();
  _has_bits_[0] &= ~0x00000400u;
}
void FeatureLayers::clear_unit_density_aa() {
  if (unit_density_aa_ != nullptr) unit_density_aa_->Clear();
  _has_bits_[0] &= ~0x00000800u;
}
void FeatureLayers::clear_unit_density() {
  if (unit_density_ != nullptr) unit_density_->Clear();
  _has_bits_[0] &= ~0x00001000u;
}
void FeatureLayers::clear_effects() {
  if (effects_ != nullptr) effects_->Clear();
  _has_bits_[0] &= ~0x00010000u;
}
void FeatureLayers::clear_hallucinations() {
  if (hallucinations_ != nullptr) hallucinations_->Clear();
  _has_bits_[0] &= ~0x00020000u;
}
void FeatureLayers::clear_cloaked() {
  if (cloaked_ != nullptr) cloaked_->Clear();
  _has_bits_[0] &= ~0x00040000u;
}
void FeatureLayers::clear_blip() {
  if (blip_ != nullptr) blip_->Clear();
  _has_bits_[0] &= ~0x00080000u;
}
void FeatureLayers::clear_buffs() {
  if (buffs_ != nullptr) buffs_->Clear();
  _has_bits_[0] &= ~0x00100000u;
}
void FeatureLayers::clear_buff_duration() {
  if (buff_duration_ != nullptr) buff_duration_->Clear();
  _has_bits_[0] &= ~0x00400000u;
}
void FeatureLayers::clear_active() {
  if (active_ != nullptr) active_->Clear();
  _has_bits_[0] &= ~0x00200000u;
}
void FeatureLayers::clear_build_progress() {
  if (build_progress_ != nullptr) build_progress_->Clear();
  _has_bits_[0] &= ~0x00800000u;
}
void FeatureLayers::clear_buildable() {
  if (buildable_ != nullptr) buildable_->Clear();
  _has_bits_[0] &= ~0x01000000u;
}
void FeatureLayers::clear_pathable() {
  if (pathable_ != nullptr) pathable_->Clear();
  _has_bits_[0] &= ~0x02000000u;
}
void FeatureLayers::clear_placeholder() {
  if (placeholder_ != nullptr) placeholder_->Clear();
  _has_bits_[0] &= ~0x04000000u;
}
FeatureLayers::FeatureLayers()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.FeatureLayers)
}
FeatureLayers::FeatureLayers(const FeatureLayers& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_height_map()) {
    height_map_ = new ::SC2APIProtocol::ImageData(*from.height_map_);
  } else {
    height_map_ = nullptr;
  }
  if (from._internal_has_visibility_map()) {
    visibility_map_ = new ::SC2APIProtocol::ImageData(*from.visibility_map_);
  } else {
    visibility_map_ = nullptr;
  }
  if (from._internal_has_creep()) {
    creep_ = new ::SC2APIProtocol::ImageData(*from.creep_);
  } else {
    creep_ = nullptr;
  }
  if (from._internal_has_power()) {
    power_ = new ::SC2APIProtocol::ImageData(*from.power_);
  } else {
    power_ = nullptr;
  }
  if (from._internal_has_player_id()) {
    player_id_ = new ::SC2APIProtocol::ImageData(*from.player_id_);
  } else {
    player_id_ = nullptr;
  }
  if (from._internal_has_unit_type()) {
    unit_type_ = new ::SC2APIProtocol::ImageData(*from.unit_type_);
  } else {
    unit_type_ = nullptr;
  }
  if (from._internal_has_selected()) {
    selected_ = new ::SC2APIProtocol::ImageData(*from.selected_);
  } else {
    selected_ = nullptr;
  }
  if (from._internal_has_unit_hit_points()) {
    unit_hit_points_ = new ::SC2APIProtocol::ImageData(*from.unit_hit_points_);
  } else {
    unit_hit_points_ = nullptr;
  }
  if (from._internal_has_unit_energy()) {
    unit_energy_ = new ::SC2APIProtocol::ImageData(*from.unit_energy_);
  } else {
    unit_energy_ = nullptr;
  }
  if (from._internal_has_unit_shields()) {
    unit_shields_ = new ::SC2APIProtocol::ImageData(*from.unit_shields_);
  } else {
    unit_shields_ = nullptr;
  }
  if (from._internal_has_player_relative()) {
    player_relative_ = new ::SC2APIProtocol::ImageData(*from.player_relative_);
  } else {
    player_relative_ = nullptr;
  }
  if (from._internal_has_unit_density_aa()) {
    unit_density_aa_ = new ::SC2APIProtocol::ImageData(*from.unit_density_aa_);
  } else {
    unit_density_aa_ = nullptr;
  }
  if (from._internal_has_unit_density()) {
    unit_density_ = new ::SC2APIProtocol::ImageData(*from.unit_density_);
  } else {
    unit_density_ = nullptr;
  }
  if (from._internal_has_unit_hit_points_ratio()) {
    unit_hit_points_ratio_ = new ::SC2APIProtocol::ImageData(*from.unit_hit_points_ratio_);
  } else {
    unit_hit_points_ratio_ = nullptr;
  }
  if (from._internal_has_unit_energy_ratio()) {
    unit_energy_ratio_ = new ::SC2APIProtocol::ImageData(*from.unit_energy_ratio_);
  } else {
    unit_energy_ratio_ = nullptr;
  }
  if (from._internal_has_unit_shields_ratio()) {
    unit_shields_ratio_ = new ::SC2APIProtocol::ImageData(*from.unit_shields_ratio_);
  } else {
    unit_shields_ratio_ = nullptr;
  }
  if (from._internal_has_effects()) {
    effects_ = new ::SC2APIProtocol::ImageData(*from.effects_);
  } else {
    effects_ = nullptr;
  }
  if (from._internal_has_hallucinations()) {
    hallucinations_ = new ::SC2APIProtocol::ImageData(*from.hallucinations_);
  } else {
    hallucinations_ = nullptr;
  }
  if (from._internal_has_cloaked()) {
    cloaked_ = new ::SC2APIProtocol::ImageData(*from.cloaked_);
  } else {
    cloaked_ = nullptr;
  }
  if (from._internal_has_blip()) {
    blip_ = new ::SC2APIProtocol::ImageData(*from.blip_);
  } else {
    blip_ = nullptr;
  }
  if (from._internal_has_buffs()) {
    buffs_ = new ::SC2APIProtocol::ImageData(*from.buffs_);
  } else {
    buffs_ = nullptr;
  }
  if (from._internal_has_active()) {
    active_ = new ::SC2APIProtocol::ImageData(*from.active_);
  } else {
    active_ = nullptr;
  }
  if (from._internal_has_buff_duration()) {
    buff_duration_ = new ::SC2APIProtocol::ImageData(*from.buff_duration_);
  } else {
    buff_duration_ = nullptr;
  }
  if (from._internal_has_build_progress()) {
    build_progress_ = new ::SC2APIProtocol::ImageData(*from.build_progress_);
  } else {
    build_progress_ = nullptr;
  }
  if (from._internal_has_buildable()) {
    buildable_ = new ::SC2APIProtocol::ImageData(*from.buildable_);
  } else {
    buildable_ = nullptr;
  }
  if (from._internal_has_pathable()) {
    pathable_ = new ::SC2APIProtocol::ImageData(*from.pathable_);
  } else {
    pathable_ = nullptr;
  }
  if (from._internal_has_placeholder()) {
    placeholder_ = new ::SC2APIProtocol::ImageData(*from.placeholder_);
  } else {
    placeholder_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.FeatureLayers)
}

void FeatureLayers::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FeatureLayers_s2clientprotocol_2fspatial_2eproto.base);
  ::memset(&height_map_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&placeholder_) -
      reinterpret_cast<char*>(&height_map_)) + sizeof(placeholder_));
}

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

void FeatureLayers::SharedDtor() {
  if (this != internal_default_instance()) delete height_map_;
  if (this != internal_default_instance()) delete visibility_map_;
  if (this != internal_default_instance()) delete creep_;
  if (this != internal_default_instance()) delete power_;
  if (this != internal_default_instance()) delete player_id_;
  if (this != internal_default_instance()) delete unit_type_;
  if (this != internal_default_instance()) delete selected_;
  if (this != internal_default_instance()) delete unit_hit_points_;
  if (this != internal_default_instance()) delete unit_energy_;
  if (this != internal_default_instance()) delete unit_shields_;
  if (this != internal_default_instance()) delete player_relative_;
  if (this != internal_default_instance()) delete unit_density_aa_;
  if (this != internal_default_instance()) delete unit_density_;
  if (this != internal_default_instance()) delete unit_hit_points_ratio_;
  if (this != internal_default_instance()) delete unit_energy_ratio_;
  if (this != internal_default_instance()) delete unit_shields_ratio_;
  if (this != internal_default_instance()) delete effects_;
  if (this != internal_default_instance()) delete hallucinations_;
  if (this != internal_default_instance()) delete cloaked_;
  if (this != internal_default_instance()) delete blip_;
  if (this != internal_default_instance()) delete buffs_;
  if (this != internal_default_instance()) delete active_;
  if (this != internal_default_instance()) delete buff_duration_;
  if (this != internal_default_instance()) delete build_progress_;
  if (this != internal_default_instance()) delete buildable_;
  if (this != internal_default_instance()) delete pathable_;
  if (this != internal_default_instance()) delete placeholder_;
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(height_map_ != nullptr);
      height_map_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(visibility_map_ != nullptr);
      visibility_map_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(creep_ != nullptr);
      creep_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(power_ != nullptr);
      power_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(player_id_ != nullptr);
      player_id_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(unit_type_ != nullptr);
      unit_type_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(selected_ != nullptr);
      selected_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(unit_hit_points_ != nullptr);
      unit_hit_points_->Clear();
    }
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(unit_energy_ != nullptr);
      unit_energy_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(unit_shields_ != nullptr);
      unit_shields_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(player_relative_ != nullptr);
      player_relative_->Clear();
    }
    if (cached_has_bits & 0x00000800u) {
      GOOGLE_DCHECK(unit_density_aa_ != nullptr);
      unit_density_aa_->Clear();
    }
    if (cached_has_bits & 0x00001000u) {
      GOOGLE_DCHECK(unit_density_ != nullptr);
      unit_density_->Clear();
    }
    if (cached_has_bits & 0x00002000u) {
      GOOGLE_DCHECK(unit_hit_points_ratio_ != nullptr);
      unit_hit_points_ratio_->Clear();
    }
    if (cached_has_bits & 0x00004000u) {
      GOOGLE_DCHECK(unit_energy_ratio_ != nullptr);
      unit_energy_ratio_->Clear();
    }
    if (cached_has_bits & 0x00008000u) {
      GOOGLE_DCHECK(unit_shields_ratio_ != nullptr);
      unit_shields_ratio_->Clear();
    }
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      GOOGLE_DCHECK(effects_ != nullptr);
      effects_->Clear();
    }
    if (cached_has_bits & 0x00020000u) {
      GOOGLE_DCHECK(hallucinations_ != nullptr);
      hallucinations_->Clear();
    }
    if (cached_has_bits & 0x00040000u) {
      GOOGLE_DCHECK(cloaked_ != nullptr);
      cloaked_->Clear();
    }
    if (cached_has_bits & 0x00080000u) {
      GOOGLE_DCHECK(blip_ != nullptr);
      blip_->Clear();
    }
    if (cached_has_bits & 0x00100000u) {
      GOOGLE_DCHECK(buffs_ != nullptr);
      buffs_->Clear();
    }
    if (cached_has_bits & 0x00200000u) {
      GOOGLE_DCHECK(active_ != nullptr);
      active_->Clear();
    }
    if (cached_has_bits & 0x00400000u) {
      GOOGLE_DCHECK(buff_duration_ != nullptr);
      buff_duration_->Clear();
    }
    if (cached_has_bits & 0x00800000u) {
      GOOGLE_DCHECK(build_progress_ != nullptr);
      build_progress_->Clear();
    }
  }
  if (cached_has_bits & 0x07000000u) {
    if (cached_has_bits & 0x01000000u) {
      GOOGLE_DCHECK(buildable_ != nullptr);
      buildable_->Clear();
    }
    if (cached_has_bits & 0x02000000u) {
      GOOGLE_DCHECK(pathable_ != nullptr);
      pathable_->Clear();
    }
    if (cached_has_bits & 0x04000000u) {
      GOOGLE_DCHECK(placeholder_ != nullptr);
      placeholder_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* FeatureLayers::_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.ImageData height_map = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_height_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData visibility_map = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_visibility_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData creep = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_creep(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData power = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_power(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData player_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_type = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_type(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData selected = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_selected(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_hit_points = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_hit_points(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_energy = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_energy(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_shields = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_shields(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData player_relative = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_relative(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_density_aa = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_density_aa(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_density = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_density(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_hit_points_ratio = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_hit_points_ratio(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_energy_ratio = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_energy_ratio(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_shields_ratio = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_shields_ratio(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData effects = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(_internal_mutable_effects(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData hallucinations = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(_internal_mutable_hallucinations(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData cloaked = 22;
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
          ptr = ctx->ParseMessage(_internal_mutable_cloaked(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData blip = 23;
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) {
          ptr = ctx->ParseMessage(_internal_mutable_blip(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData buffs = 24;
      case 24:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) {
          ptr = ctx->ParseMessage(_internal_mutable_buffs(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData active = 25;
      case 25:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) {
          ptr = ctx->ParseMessage(_internal_mutable_active(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData buff_duration = 26;
      case 26:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) {
          ptr = ctx->ParseMessage(_internal_mutable_buff_duration(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData build_progress = 27;
      case 27:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) {
          ptr = ctx->ParseMessage(_internal_mutable_build_progress(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData buildable = 28;
      case 28:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) {
          ptr = ctx->ParseMessage(_internal_mutable_buildable(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData pathable = 29;
      case 29:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) {
          ptr = ctx->ParseMessage(_internal_mutable_pathable(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData placeholder = 30;
      case 30:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) {
          ptr = ctx->ParseMessage(_internal_mutable_placeholder(), 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* FeatureLayers::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.FeatureLayers)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

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

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

  // optional .SC2APIProtocol.ImageData unit_type = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::unit_type(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData selected = 7;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::selected(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_hit_points = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::unit_hit_points(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_energy = 9;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::unit_energy(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_shields = 10;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::unit_shields(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData player_relative = 11;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::player_relative(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_density_aa = 14;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        14, _Internal::unit_density_aa(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_density = 15;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        15, _Internal::unit_density(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_hit_points_ratio = 17;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        17, _Internal::unit_hit_points_ratio(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_energy_ratio = 18;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        18, _Internal::unit_energy_ratio(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_shields_ratio = 19;
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        19, _Internal::unit_shields_ratio(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData effects = 20;
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        20, _Internal::effects(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData hallucinations = 21;
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        21, _Internal::hallucinations(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData cloaked = 22;
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        22, _Internal::cloaked(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData blip = 23;
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        23, _Internal::blip(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData buffs = 24;
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        24, _Internal::buffs(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData active = 25;
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        25, _Internal::active(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData buff_duration = 26;
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        26, _Internal::buff_duration(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData build_progress = 27;
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        27, _Internal::build_progress(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData buildable = 28;
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        28, _Internal::buildable(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData pathable = 29;
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        29, _Internal::pathable(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData placeholder = 30;
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        30, _Internal::placeholder(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.FeatureLayers)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .SC2APIProtocol.ImageData height_map = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *height_map_);
    }

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

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

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

    // optional .SC2APIProtocol.ImageData player_id = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_id_);
    }

    // optional .SC2APIProtocol.ImageData unit_type = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_type_);
    }

    // optional .SC2APIProtocol.ImageData selected = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *selected_);
    }

    // optional .SC2APIProtocol.ImageData unit_hit_points = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_hit_points_);
    }

  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional .SC2APIProtocol.ImageData unit_energy = 9;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_energy_);
    }

    // optional .SC2APIProtocol.ImageData unit_shields = 10;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_shields_);
    }

    // optional .SC2APIProtocol.ImageData player_relative = 11;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_relative_);
    }

    // optional .SC2APIProtocol.ImageData unit_density_aa = 14;
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_density_aa_);
    }

    // optional .SC2APIProtocol.ImageData unit_density = 15;
    if (cached_has_bits & 0x00001000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_density_);
    }

    // optional .SC2APIProtocol.ImageData unit_hit_points_ratio = 17;
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_hit_points_ratio_);
    }

    // optional .SC2APIProtocol.ImageData unit_energy_ratio = 18;
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_energy_ratio_);
    }

    // optional .SC2APIProtocol.ImageData unit_shields_ratio = 19;
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_shields_ratio_);
    }

  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional .SC2APIProtocol.ImageData effects = 20;
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *effects_);
    }

    // optional .SC2APIProtocol.ImageData hallucinations = 21;
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *hallucinations_);
    }

    // optional .SC2APIProtocol.ImageData cloaked = 22;
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *cloaked_);
    }

    // optional .SC2APIProtocol.ImageData blip = 23;
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *blip_);
    }

    // optional .SC2APIProtocol.ImageData buffs = 24;
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *buffs_);
    }

    // optional .SC2APIProtocol.ImageData active = 25;
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *active_);
    }

    // optional .SC2APIProtocol.ImageData buff_duration = 26;
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *buff_duration_);
    }

    // optional .SC2APIProtocol.ImageData build_progress = 27;
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *build_progress_);
    }

  }
  if (cached_has_bits & 0x07000000u) {
    // optional .SC2APIProtocol.ImageData buildable = 28;
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *buildable_);
    }

    // optional .SC2APIProtocol.ImageData pathable = 29;
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *pathable_);
    }

    // optional .SC2APIProtocol.ImageData placeholder = 30;
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *placeholder_);
    }

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

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

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_height_map()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_height_map());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_visibility_map()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_visibility_map());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_creep()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_creep());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_power()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_power());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_player_id()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_player_id());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_mutable_unit_type()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_type());
    }
    if (cached_has_bits & 0x00000040u) {
      _internal_mutable_selected()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_selected());
    }
    if (cached_has_bits & 0x00000080u) {
      _internal_mutable_unit_hit_points()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_hit_points());
    }
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      _internal_mutable_unit_energy()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_energy());
    }
    if (cached_has_bits & 0x00000200u) {
      _internal_mutable_unit_shields()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_shields());
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_mutable_player_relative()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_player_relative());
    }
    if (cached_has_bits & 0x00000800u) {
      _internal_mutable_unit_density_aa()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_density_aa());
    }
    if (cached_has_bits & 0x00001000u) {
      _internal_mutable_unit_density()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_density());
    }
    if (cached_has_bits & 0x00002000u) {
      _internal_mutable_unit_hit_points_ratio()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_hit_points_ratio());
    }
    if (cached_has_bits & 0x00004000u) {
      _internal_mutable_unit_energy_ratio()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_energy_ratio());
    }
    if (cached_has_bits & 0x00008000u) {
      _internal_mutable_unit_shields_ratio()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_shields_ratio());
    }
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      _internal_mutable_effects()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_effects());
    }
    if (cached_has_bits & 0x00020000u) {
      _internal_mutable_hallucinations()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_hallucinations());
    }
    if (cached_has_bits & 0x00040000u) {
      _internal_mutable_cloaked()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_cloaked());
    }
    if (cached_has_bits & 0x00080000u) {
      _internal_mutable_blip()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_blip());
    }
    if (cached_has_bits & 0x00100000u) {
      _internal_mutable_buffs()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_buffs());
    }
    if (cached_has_bits & 0x00200000u) {
      _internal_mutable_active()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_active());
    }
    if (cached_has_bits & 0x00400000u) {
      _internal_mutable_buff_duration()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_buff_duration());
    }
    if (cached_has_bits & 0x00800000u) {
      _internal_mutable_build_progress()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_build_progress());
    }
  }
  if (cached_has_bits & 0x07000000u) {
    if (cached_has_bits & 0x01000000u) {
      _internal_mutable_buildable()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_buildable());
    }
    if (cached_has_bits & 0x02000000u) {
      _internal_mutable_pathable()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_pathable());
    }
    if (cached_has_bits & 0x04000000u) {
      _internal_mutable_placeholder()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_placeholder());
    }
  }
}

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

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

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

void FeatureLayers::InternalSwap(FeatureLayers* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(height_map_, other->height_map_);
  swap(visibility_map_, other->visibility_map_);
  swap(creep_, other->creep_);
  swap(power_, other->power_);
  swap(player_id_, other->player_id_);
  swap(unit_type_, other->unit_type_);
  swap(selected_, other->selected_);
  swap(unit_hit_points_, other->unit_hit_points_);
  swap(unit_energy_, other->unit_energy_);
  swap(unit_shields_, other->unit_shields_);
  swap(player_relative_, other->player_relative_);
  swap(unit_density_aa_, other->unit_density_aa_);
  swap(unit_density_, other->unit_density_);
  swap(unit_hit_points_ratio_, other->unit_hit_points_ratio_);
  swap(unit_energy_ratio_, other->unit_energy_ratio_);
  swap(unit_shields_ratio_, other->unit_shields_ratio_);
  swap(effects_, other->effects_);
  swap(hallucinations_, other->hallucinations_);
  swap(cloaked_, other->cloaked_);
  swap(blip_, other->blip_);
  swap(buffs_, other->buffs_);
  swap(active_, other->active_);
  swap(buff_duration_, other->buff_duration_);
  swap(build_progress_, other->build_progress_);
  swap(buildable_, other->buildable_);
  swap(pathable_, other->pathable_);
  swap(placeholder_, other->placeholder_);
}

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


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

void FeatureLayersMinimap::InitAsDefaultInstance() {
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->height_map_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->visibility_map_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->creep_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->camera_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->player_id_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->player_relative_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->selected_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->alerts_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->buildable_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->pathable_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_FeatureLayersMinimap_default_instance_._instance.get_mutable()->unit_type_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
}
class FeatureLayersMinimap::_Internal {
 public:
  using HasBits = decltype(std::declval<FeatureLayersMinimap>()._has_bits_);
  static const ::SC2APIProtocol::ImageData& height_map(const FeatureLayersMinimap* msg);
  static void set_has_height_map(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::ImageData& visibility_map(const FeatureLayersMinimap* msg);
  static void set_has_visibility_map(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::SC2APIProtocol::ImageData& creep(const FeatureLayersMinimap* msg);
  static void set_has_creep(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::SC2APIProtocol::ImageData& camera(const FeatureLayersMinimap* msg);
  static void set_has_camera(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::SC2APIProtocol::ImageData& player_id(const FeatureLayersMinimap* msg);
  static void set_has_player_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::SC2APIProtocol::ImageData& player_relative(const FeatureLayersMinimap* msg);
  static void set_has_player_relative(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::SC2APIProtocol::ImageData& selected(const FeatureLayersMinimap* msg);
  static void set_has_selected(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::SC2APIProtocol::ImageData& alerts(const FeatureLayersMinimap* msg);
  static void set_has_alerts(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static const ::SC2APIProtocol::ImageData& buildable(const FeatureLayersMinimap* msg);
  static void set_has_buildable(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static const ::SC2APIProtocol::ImageData& pathable(const FeatureLayersMinimap* msg);
  static void set_has_pathable(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static const ::SC2APIProtocol::ImageData& unit_type(const FeatureLayersMinimap* msg);
  static void set_has_unit_type(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
};

const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::height_map(const FeatureLayersMinimap* msg) {
  return *msg->height_map_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::visibility_map(const FeatureLayersMinimap* msg) {
  return *msg->visibility_map_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::creep(const FeatureLayersMinimap* msg) {
  return *msg->creep_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::camera(const FeatureLayersMinimap* msg) {
  return *msg->camera_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::player_id(const FeatureLayersMinimap* msg) {
  return *msg->player_id_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::player_relative(const FeatureLayersMinimap* msg) {
  return *msg->player_relative_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::selected(const FeatureLayersMinimap* msg) {
  return *msg->selected_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::alerts(const FeatureLayersMinimap* msg) {
  return *msg->alerts_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::buildable(const FeatureLayersMinimap* msg) {
  return *msg->buildable_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::pathable(const FeatureLayersMinimap* msg) {
  return *msg->pathable_;
}
const ::SC2APIProtocol::ImageData&
FeatureLayersMinimap::_Internal::unit_type(const FeatureLayersMinimap* msg) {
  return *msg->unit_type_;
}
void FeatureLayersMinimap::clear_height_map() {
  if (height_map_ != nullptr) height_map_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void FeatureLayersMinimap::clear_visibility_map() {
  if (visibility_map_ != nullptr) visibility_map_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
void FeatureLayersMinimap::clear_creep() {
  if (creep_ != nullptr) creep_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
void FeatureLayersMinimap::clear_camera() {
  if (camera_ != nullptr) camera_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
void FeatureLayersMinimap::clear_player_id() {
  if (player_id_ != nullptr) player_id_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
void FeatureLayersMinimap::clear_player_relative() {
  if (player_relative_ != nullptr) player_relative_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
void FeatureLayersMinimap::clear_selected() {
  if (selected_ != nullptr) selected_->Clear();
  _has_bits_[0] &= ~0x00000040u;
}
void FeatureLayersMinimap::clear_alerts() {
  if (alerts_ != nullptr) alerts_->Clear();
  _has_bits_[0] &= ~0x00000100u;
}
void FeatureLayersMinimap::clear_buildable() {
  if (buildable_ != nullptr) buildable_->Clear();
  _has_bits_[0] &= ~0x00000200u;
}
void FeatureLayersMinimap::clear_pathable() {
  if (pathable_ != nullptr) pathable_->Clear();
  _has_bits_[0] &= ~0x00000400u;
}
void FeatureLayersMinimap::clear_unit_type() {
  if (unit_type_ != nullptr) unit_type_->Clear();
  _has_bits_[0] &= ~0x00000080u;
}
FeatureLayersMinimap::FeatureLayersMinimap()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.FeatureLayersMinimap)
}
FeatureLayersMinimap::FeatureLayersMinimap(const FeatureLayersMinimap& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_height_map()) {
    height_map_ = new ::SC2APIProtocol::ImageData(*from.height_map_);
  } else {
    height_map_ = nullptr;
  }
  if (from._internal_has_visibility_map()) {
    visibility_map_ = new ::SC2APIProtocol::ImageData(*from.visibility_map_);
  } else {
    visibility_map_ = nullptr;
  }
  if (from._internal_has_creep()) {
    creep_ = new ::SC2APIProtocol::ImageData(*from.creep_);
  } else {
    creep_ = nullptr;
  }
  if (from._internal_has_camera()) {
    camera_ = new ::SC2APIProtocol::ImageData(*from.camera_);
  } else {
    camera_ = nullptr;
  }
  if (from._internal_has_player_id()) {
    player_id_ = new ::SC2APIProtocol::ImageData(*from.player_id_);
  } else {
    player_id_ = nullptr;
  }
  if (from._internal_has_player_relative()) {
    player_relative_ = new ::SC2APIProtocol::ImageData(*from.player_relative_);
  } else {
    player_relative_ = nullptr;
  }
  if (from._internal_has_selected()) {
    selected_ = new ::SC2APIProtocol::ImageData(*from.selected_);
  } else {
    selected_ = nullptr;
  }
  if (from._internal_has_unit_type()) {
    unit_type_ = new ::SC2APIProtocol::ImageData(*from.unit_type_);
  } else {
    unit_type_ = nullptr;
  }
  if (from._internal_has_alerts()) {
    alerts_ = new ::SC2APIProtocol::ImageData(*from.alerts_);
  } else {
    alerts_ = nullptr;
  }
  if (from._internal_has_buildable()) {
    buildable_ = new ::SC2APIProtocol::ImageData(*from.buildable_);
  } else {
    buildable_ = nullptr;
  }
  if (from._internal_has_pathable()) {
    pathable_ = new ::SC2APIProtocol::ImageData(*from.pathable_);
  } else {
    pathable_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.FeatureLayersMinimap)
}

void FeatureLayersMinimap::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FeatureLayersMinimap_s2clientprotocol_2fspatial_2eproto.base);
  ::memset(&height_map_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&pathable_) -
      reinterpret_cast<char*>(&height_map_)) + sizeof(pathable_));
}

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

void FeatureLayersMinimap::SharedDtor() {
  if (this != internal_default_instance()) delete height_map_;
  if (this != internal_default_instance()) delete visibility_map_;
  if (this != internal_default_instance()) delete creep_;
  if (this != internal_default_instance()) delete camera_;
  if (this != internal_default_instance()) delete player_id_;
  if (this != internal_default_instance()) delete player_relative_;
  if (this != internal_default_instance()) delete selected_;
  if (this != internal_default_instance()) delete unit_type_;
  if (this != internal_default_instance()) delete alerts_;
  if (this != internal_default_instance()) delete buildable_;
  if (this != internal_default_instance()) delete pathable_;
}

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


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(height_map_ != nullptr);
      height_map_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(visibility_map_ != nullptr);
      visibility_map_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(creep_ != nullptr);
      creep_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(camera_ != nullptr);
      camera_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(player_id_ != nullptr);
      player_id_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      GOOGLE_DCHECK(player_relative_ != nullptr);
      player_relative_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(selected_ != nullptr);
      selected_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(unit_type_ != nullptr);
      unit_type_->Clear();
    }
  }
  if (cached_has_bits & 0x00000700u) {
    if (cached_has_bits & 0x00000100u) {
      GOOGLE_DCHECK(alerts_ != nullptr);
      alerts_->Clear();
    }
    if (cached_has_bits & 0x00000200u) {
      GOOGLE_DCHECK(buildable_ != nullptr);
      buildable_->Clear();
    }
    if (cached_has_bits & 0x00000400u) {
      GOOGLE_DCHECK(pathable_ != nullptr);
      pathable_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* FeatureLayersMinimap::_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.ImageData height_map = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_height_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData visibility_map = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_visibility_map(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData creep = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_creep(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData camera = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_camera(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData player_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_id(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData player_relative = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_player_relative(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData selected = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_selected(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData unit_type = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_type(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData alerts = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_alerts(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData buildable = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_buildable(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ImageData pathable = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_pathable(), 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* FeatureLayersMinimap::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.FeatureLayersMinimap)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

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

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

  // optional .SC2APIProtocol.ImageData player_relative = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::player_relative(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData selected = 7;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::selected(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData unit_type = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::unit_type(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData alerts = 9;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::alerts(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData buildable = 10;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::buildable(this), target, stream);
  }

  // optional .SC2APIProtocol.ImageData pathable = 11;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::pathable(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.FeatureLayersMinimap)
  return target;
}

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

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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .SC2APIProtocol.ImageData height_map = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *height_map_);
    }

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

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

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

    // optional .SC2APIProtocol.ImageData player_id = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_id_);
    }

    // optional .SC2APIProtocol.ImageData player_relative = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *player_relative_);
    }

    // optional .SC2APIProtocol.ImageData selected = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *selected_);
    }

    // optional .SC2APIProtocol.ImageData unit_type = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *unit_type_);
    }

  }
  if (cached_has_bits & 0x00000700u) {
    // optional .SC2APIProtocol.ImageData alerts = 9;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *alerts_);
    }

    // optional .SC2APIProtocol.ImageData buildable = 10;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *buildable_);
    }

    // optional .SC2APIProtocol.ImageData pathable = 11;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *pathable_);
    }

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

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

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_height_map()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_height_map());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_visibility_map()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_visibility_map());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_creep()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_creep());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_mutable_camera()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_camera());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_mutable_player_id()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_player_id());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_mutable_player_relative()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_player_relative());
    }
    if (cached_has_bits & 0x00000040u) {
      _internal_mutable_selected()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_selected());
    }
    if (cached_has_bits & 0x00000080u) {
      _internal_mutable_unit_type()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_unit_type());
    }
  }
  if (cached_has_bits & 0x00000700u) {
    if (cached_has_bits & 0x00000100u) {
      _internal_mutable_alerts()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_alerts());
    }
    if (cached_has_bits & 0x00000200u) {
      _internal_mutable_buildable()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_buildable());
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_mutable_pathable()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_pathable());
    }
  }
}

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

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

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

void FeatureLayersMinimap::InternalSwap(FeatureLayersMinimap* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(height_map_, other->height_map_);
  swap(visibility_map_, other->visibility_map_);
  swap(creep_, other->creep_);
  swap(camera_, other->camera_);
  swap(player_id_, other->player_id_);
  swap(player_relative_, other->player_relative_);
  swap(selected_, other->selected_);
  swap(unit_type_, other->unit_type_);
  swap(alerts_, other->alerts_);
  swap(buildable_, other->buildable_);
  swap(pathable_, other->pathable_);
}

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


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

void ObservationRender::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ObservationRender_default_instance_._instance.get_mutable()->map_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
  ::SC2APIProtocol::_ObservationRender_default_instance_._instance.get_mutable()->minimap_ = const_cast< ::SC2APIProtocol::ImageData*>(
      ::SC2APIProtocol::ImageData::internal_default_instance());
}
class ObservationRender::_Internal {
 public:
  using HasBits = decltype(std::declval<ObservationRender>()._has_bits_);
  static const ::SC2APIProtocol::ImageData& map(const ObservationRender* msg);
  static void set_has_map(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::ImageData& minimap(const ObservationRender* msg);
  static void set_has_minimap(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::ImageData&
ObservationRender::_Internal::map(const ObservationRender* msg) {
  return *msg->map_;
}
const ::SC2APIProtocol::ImageData&
ObservationRender::_Internal::minimap(const ObservationRender* msg) {
  return *msg->minimap_;
}
void ObservationRender::clear_map() {
  if (map_ != nullptr) map_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
void ObservationRender::clear_minimap() {
  if (minimap_ != nullptr) minimap_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
ObservationRender::ObservationRender()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ObservationRender)
}
ObservationRender::ObservationRender(const ObservationRender& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_map()) {
    map_ = new ::SC2APIProtocol::ImageData(*from.map_);
  } else {
    map_ = nullptr;
  }
  if (from._internal_has_minimap()) {
    minimap_ = new ::SC2APIProtocol::ImageData(*from.minimap_);
  } else {
    minimap_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ObservationRender)
}

void ObservationRender::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ObservationRender_s2clientprotocol_2fspatial_2eproto.base);
  ::memset(&map_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&minimap_) -
      reinterpret_cast<char*>(&map_)) + sizeof(minimap_));
}

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

void ObservationRender::SharedDtor() {
  if (this != internal_default_instance()) delete map_;
  if (this != internal_default_instance()) delete minimap_;
}

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


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

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

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

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

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

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

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

void ObservationRender::MergeFrom(const ObservationRender& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ObservationRender)
  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_map()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_map());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_minimap()->::SC2APIProtocol::ImageData::MergeFrom(from._internal_minimap());
    }
  }
}

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

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

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

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

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


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

void ActionSpatial::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ActionSpatial_default_instance_.unit_command_ = const_cast< ::SC2APIProtocol::ActionSpatialUnitCommand*>(
      ::SC2APIProtocol::ActionSpatialUnitCommand::internal_default_instance());
  ::SC2APIProtocol::_ActionSpatial_default_instance_.camera_move_ = const_cast< ::SC2APIProtocol::ActionSpatialCameraMove*>(
      ::SC2APIProtocol::ActionSpatialCameraMove::internal_default_instance());
  ::SC2APIProtocol::_ActionSpatial_default_instance_.unit_selection_point_ = const_cast< ::SC2APIProtocol::ActionSpatialUnitSelectionPoint*>(
      ::SC2APIProtocol::ActionSpatialUnitSelectionPoint::internal_default_instance());
  ::SC2APIProtocol::_ActionSpatial_default_instance_.unit_selection_rect_ = const_cast< ::SC2APIProtocol::ActionSpatialUnitSelectionRect*>(
      ::SC2APIProtocol::ActionSpatialUnitSelectionRect::internal_default_instance());
}
class ActionSpatial::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionSpatial>()._has_bits_);
  static const ::SC2APIProtocol::ActionSpatialUnitCommand& unit_command(const ActionSpatial* msg);
  static const ::SC2APIProtocol::ActionSpatialCameraMove& camera_move(const ActionSpatial* msg);
  static const ::SC2APIProtocol::ActionSpatialUnitSelectionPoint& unit_selection_point(const ActionSpatial* msg);
  static const ::SC2APIProtocol::ActionSpatialUnitSelectionRect& unit_selection_rect(const ActionSpatial* msg);
};

const ::SC2APIProtocol::ActionSpatialUnitCommand&
ActionSpatial::_Internal::unit_command(const ActionSpatial* msg) {
  return *msg->action_.unit_command_;
}
const ::SC2APIProtocol::ActionSpatialCameraMove&
ActionSpatial::_Internal::camera_move(const ActionSpatial* msg) {
  return *msg->action_.camera_move_;
}
const ::SC2APIProtocol::ActionSpatialUnitSelectionPoint&
ActionSpatial::_Internal::unit_selection_point(const ActionSpatial* msg) {
  return *msg->action_.unit_selection_point_;
}
const ::SC2APIProtocol::ActionSpatialUnitSelectionRect&
ActionSpatial::_Internal::unit_selection_rect(const ActionSpatial* msg) {
  return *msg->action_.unit_selection_rect_;
}
void ActionSpatial::set_allocated_unit_command(::SC2APIProtocol::ActionSpatialUnitCommand* unit_command) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (unit_command) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      unit_command = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unit_command, submessage_arena);
    }
    set_has_unit_command();
    action_.unit_command_ = unit_command;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ActionSpatial.unit_command)
}
void ActionSpatial::set_allocated_camera_move(::SC2APIProtocol::ActionSpatialCameraMove* camera_move) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (camera_move) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      camera_move = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, camera_move, submessage_arena);
    }
    set_has_camera_move();
    action_.camera_move_ = camera_move;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ActionSpatial.camera_move)
}
void ActionSpatial::set_allocated_unit_selection_point(::SC2APIProtocol::ActionSpatialUnitSelectionPoint* unit_selection_point) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (unit_selection_point) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      unit_selection_point = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unit_selection_point, submessage_arena);
    }
    set_has_unit_selection_point();
    action_.unit_selection_point_ = unit_selection_point;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ActionSpatial.unit_selection_point)
}
void ActionSpatial::set_allocated_unit_selection_rect(::SC2APIProtocol::ActionSpatialUnitSelectionRect* unit_selection_rect) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_action();
  if (unit_selection_rect) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      unit_selection_rect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unit_selection_rect, submessage_arena);
    }
    set_has_unit_selection_rect();
    action_.unit_selection_rect_ = unit_selection_rect;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ActionSpatial.unit_selection_rect)
}
ActionSpatial::ActionSpatial()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionSpatial)
}
ActionSpatial::ActionSpatial(const ActionSpatial& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_action();
  switch (from.action_case()) {
    case kUnitCommand: {
      _internal_mutable_unit_command()->::SC2APIProtocol::ActionSpatialUnitCommand::MergeFrom(from._internal_unit_command());
      break;
    }
    case kCameraMove: {
      _internal_mutable_camera_move()->::SC2APIProtocol::ActionSpatialCameraMove::MergeFrom(from._internal_camera_move());
      break;
    }
    case kUnitSelectionPoint: {
      _internal_mutable_unit_selection_point()->::SC2APIProtocol::ActionSpatialUnitSelectionPoint::MergeFrom(from._internal_unit_selection_point());
      break;
    }
    case kUnitSelectionRect: {
      _internal_mutable_unit_selection_rect()->::SC2APIProtocol::ActionSpatialUnitSelectionRect::MergeFrom(from._internal_unit_selection_rect());
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionSpatial)
}

void ActionSpatial::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionSpatial_s2clientprotocol_2fspatial_2eproto.base);
  clear_has_action();
}

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

void ActionSpatial::SharedDtor() {
  if (has_action()) {
    clear_action();
  }
}

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


void ActionSpatial::clear_action() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.ActionSpatial)
  switch (action_case()) {
    case kUnitCommand: {
      delete action_.unit_command_;
      break;
    }
    case kCameraMove: {
      delete action_.camera_move_;
      break;
    }
    case kUnitSelectionPoint: {
      delete action_.unit_selection_point_;
      break;
    }
    case kUnitSelectionRect: {
      delete action_.unit_selection_rect_;
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = ACTION_NOT_SET;
}


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

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

const char* ActionSpatial::_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.ActionSpatialUnitCommand unit_command = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_command(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionSpatialCameraMove camera_move = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_camera_move(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionSpatialUnitSelectionPoint unit_selection_point = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_selection_point(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionSpatialUnitSelectionRect unit_selection_rect = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_unit_selection_rect(), 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* ActionSpatial::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ActionSpatial)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (action_case()) {
    case kUnitCommand: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::unit_command(this), target, stream);
      break;
    }
    case kCameraMove: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::camera_move(this), target, stream);
      break;
    }
    case kUnitSelectionPoint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::unit_selection_point(this), target, stream);
      break;
    }
    case kUnitSelectionRect: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::unit_selection_rect(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.ActionSpatial)
  return target;
}

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

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

  switch (action_case()) {
    // optional .SC2APIProtocol.ActionSpatialUnitCommand unit_command = 1;
    case kUnitCommand: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.unit_command_);
      break;
    }
    // optional .SC2APIProtocol.ActionSpatialCameraMove camera_move = 2;
    case kCameraMove: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.camera_move_);
      break;
    }
    // optional .SC2APIProtocol.ActionSpatialUnitSelectionPoint unit_selection_point = 3;
    case kUnitSelectionPoint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.unit_selection_point_);
      break;
    }
    // optional .SC2APIProtocol.ActionSpatialUnitSelectionRect unit_selection_rect = 4;
    case kUnitSelectionRect: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *action_.unit_selection_rect_);
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.action_case()) {
    case kUnitCommand: {
      _internal_mutable_unit_command()->::SC2APIProtocol::ActionSpatialUnitCommand::MergeFrom(from._internal_unit_command());
      break;
    }
    case kCameraMove: {
      _internal_mutable_camera_move()->::SC2APIProtocol::ActionSpatialCameraMove::MergeFrom(from._internal_camera_move());
      break;
    }
    case kUnitSelectionPoint: {
      _internal_mutable_unit_selection_point()->::SC2APIProtocol::ActionSpatialUnitSelectionPoint::MergeFrom(from._internal_unit_selection_point());
      break;
    }
    case kUnitSelectionRect: {
      _internal_mutable_unit_selection_rect()->::SC2APIProtocol::ActionSpatialUnitSelectionRect::MergeFrom(from._internal_unit_selection_rect());
      break;
    }
    case ACTION_NOT_SET: {
      break;
    }
  }
}

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

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

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

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

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


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

void ActionSpatialUnitCommand::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ActionSpatialUnitCommand_default_instance_.target_screen_coord_ = const_cast< ::SC2APIProtocol::PointI*>(
      ::SC2APIProtocol::PointI::internal_default_instance());
  ::SC2APIProtocol::_ActionSpatialUnitCommand_default_instance_.target_minimap_coord_ = const_cast< ::SC2APIProtocol::PointI*>(
      ::SC2APIProtocol::PointI::internal_default_instance());
}
class ActionSpatialUnitCommand::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionSpatialUnitCommand>()._has_bits_);
  static void set_has_ability_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::SC2APIProtocol::PointI& target_screen_coord(const ActionSpatialUnitCommand* msg);
  static const ::SC2APIProtocol::PointI& target_minimap_coord(const ActionSpatialUnitCommand* msg);
  static void set_has_queue_command(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::PointI&
ActionSpatialUnitCommand::_Internal::target_screen_coord(const ActionSpatialUnitCommand* msg) {
  return *msg->target_.target_screen_coord_;
}
const ::SC2APIProtocol::PointI&
ActionSpatialUnitCommand::_Internal::target_minimap_coord(const ActionSpatialUnitCommand* msg) {
  return *msg->target_.target_minimap_coord_;
}
void ActionSpatialUnitCommand::set_allocated_target_screen_coord(::SC2APIProtocol::PointI* target_screen_coord) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_target();
  if (target_screen_coord) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      target_screen_coord = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, target_screen_coord, submessage_arena);
    }
    set_has_target_screen_coord();
    target_.target_screen_coord_ = target_screen_coord;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ActionSpatialUnitCommand.target_screen_coord)
}
void ActionSpatialUnitCommand::clear_target_screen_coord() {
  if (_internal_has_target_screen_coord()) {
    delete target_.target_screen_coord_;
    clear_has_target();
  }
}
void ActionSpatialUnitCommand::set_allocated_target_minimap_coord(::SC2APIProtocol::PointI* target_minimap_coord) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_target();
  if (target_minimap_coord) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      target_minimap_coord = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, target_minimap_coord, submessage_arena);
    }
    set_has_target_minimap_coord();
    target_.target_minimap_coord_ = target_minimap_coord;
  }
  // @@protoc_insertion_point(field_set_allocated:SC2APIProtocol.ActionSpatialUnitCommand.target_minimap_coord)
}
void ActionSpatialUnitCommand::clear_target_minimap_coord() {
  if (_internal_has_target_minimap_coord()) {
    delete target_.target_minimap_coord_;
    clear_has_target();
  }
}
ActionSpatialUnitCommand::ActionSpatialUnitCommand()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionSpatialUnitCommand)
}
ActionSpatialUnitCommand::ActionSpatialUnitCommand(const ActionSpatialUnitCommand& 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*>(&queue_command_) -
    reinterpret_cast<char*>(&ability_id_)) + sizeof(queue_command_));
  clear_has_target();
  switch (from.target_case()) {
    case kTargetScreenCoord: {
      _internal_mutable_target_screen_coord()->::SC2APIProtocol::PointI::MergeFrom(from._internal_target_screen_coord());
      break;
    }
    case kTargetMinimapCoord: {
      _internal_mutable_target_minimap_coord()->::SC2APIProtocol::PointI::MergeFrom(from._internal_target_minimap_coord());
      break;
    }
    case TARGET_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionSpatialUnitCommand)
}

void ActionSpatialUnitCommand::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionSpatialUnitCommand_s2clientprotocol_2fspatial_2eproto.base);
  ::memset(&ability_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&queue_command_) -
      reinterpret_cast<char*>(&ability_id_)) + sizeof(queue_command_));
  clear_has_target();
}

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

void ActionSpatialUnitCommand::SharedDtor() {
  if (has_target()) {
    clear_target();
  }
}

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


void ActionSpatialUnitCommand::clear_target() {
// @@protoc_insertion_point(one_of_clear_start:SC2APIProtocol.ActionSpatialUnitCommand)
  switch (target_case()) {
    case kTargetScreenCoord: {
      delete target_.target_screen_coord_;
      break;
    }
    case kTargetMinimapCoord: {
      delete target_.target_minimap_coord_;
      break;
    }
    case TARGET_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = TARGET_NOT_SET;
}


void ActionSpatialUnitCommand::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ActionSpatialUnitCommand)
  ::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*>(&queue_command_) -
        reinterpret_cast<char*>(&ability_id_)) + sizeof(queue_command_));
  }
  clear_target();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionSpatialUnitCommand::_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 .SC2APIProtocol.PointI target_screen_coord = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_target_screen_coord(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.PointI target_minimap_coord = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_target_minimap_coord(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool queue_command = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_queue_command(&has_bits);
          queue_command_ = ::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* ActionSpatialUnitCommand::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ActionSpatialUnitCommand)
  ::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);
  }

  switch (target_case()) {
    case kTargetScreenCoord: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::target_screen_coord(this), target, stream);
      break;
    }
    case kTargetMinimapCoord: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::target_minimap_coord(this), target, stream);
      break;
    }
    default: ;
  }
  // optional bool queue_command = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_queue_command(), 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.ActionSpatialUnitCommand)
  return target;
}

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

  }
  switch (target_case()) {
    // optional .SC2APIProtocol.PointI target_screen_coord = 2;
    case kTargetScreenCoord: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *target_.target_screen_coord_);
      break;
    }
    // optional .SC2APIProtocol.PointI target_minimap_coord = 3;
    case kTargetMinimapCoord: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *target_.target_minimap_coord_);
      break;
    }
    case TARGET_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 ActionSpatialUnitCommand::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionSpatialUnitCommand)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionSpatialUnitCommand* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionSpatialUnitCommand>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionSpatialUnitCommand)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionSpatialUnitCommand)
    MergeFrom(*source);
  }
}

void ActionSpatialUnitCommand::MergeFrom(const ActionSpatialUnitCommand& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ActionSpatialUnitCommand)
  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) {
      queue_command_ = from.queue_command_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.target_case()) {
    case kTargetScreenCoord: {
      _internal_mutable_target_screen_coord()->::SC2APIProtocol::PointI::MergeFrom(from._internal_target_screen_coord());
      break;
    }
    case kTargetMinimapCoord: {
      _internal_mutable_target_minimap_coord()->::SC2APIProtocol::PointI::MergeFrom(from._internal_target_minimap_coord());
      break;
    }
    case TARGET_NOT_SET: {
      break;
    }
  }
}

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

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

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

void ActionSpatialUnitCommand::InternalSwap(ActionSpatialUnitCommand* 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(queue_command_, other->queue_command_);
  swap(target_, other->target_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void ActionSpatialCameraMove::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ActionSpatialCameraMove_default_instance_._instance.get_mutable()->center_minimap_ = const_cast< ::SC2APIProtocol::PointI*>(
      ::SC2APIProtocol::PointI::internal_default_instance());
}
class ActionSpatialCameraMove::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionSpatialCameraMove>()._has_bits_);
  static const ::SC2APIProtocol::PointI& center_minimap(const ActionSpatialCameraMove* msg);
  static void set_has_center_minimap(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::SC2APIProtocol::PointI&
ActionSpatialCameraMove::_Internal::center_minimap(const ActionSpatialCameraMove* msg) {
  return *msg->center_minimap_;
}
void ActionSpatialCameraMove::clear_center_minimap() {
  if (center_minimap_ != nullptr) center_minimap_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
ActionSpatialCameraMove::ActionSpatialCameraMove()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionSpatialCameraMove)
}
ActionSpatialCameraMove::ActionSpatialCameraMove(const ActionSpatialCameraMove& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_center_minimap()) {
    center_minimap_ = new ::SC2APIProtocol::PointI(*from.center_minimap_);
  } else {
    center_minimap_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionSpatialCameraMove)
}

void ActionSpatialCameraMove::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionSpatialCameraMove_s2clientprotocol_2fspatial_2eproto.base);
  center_minimap_ = nullptr;
}

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

void ActionSpatialCameraMove::SharedDtor() {
  if (this != internal_default_instance()) delete center_minimap_;
}

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


void ActionSpatialCameraMove::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ActionSpatialCameraMove)
  ::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(center_minimap_ != nullptr);
    center_minimap_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionSpatialCameraMove::_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 center_minimap = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_center_minimap(), 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* ActionSpatialCameraMove::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ActionSpatialCameraMove)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .SC2APIProtocol.PointI center_minimap = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::center_minimap(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.ActionSpatialCameraMove)
  return target;
}

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

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

void ActionSpatialCameraMove::MergeFrom(const ActionSpatialCameraMove& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:SC2APIProtocol.ActionSpatialCameraMove)
  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_center_minimap()) {
    _internal_mutable_center_minimap()->::SC2APIProtocol::PointI::MergeFrom(from._internal_center_minimap());
  }
}

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

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

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

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

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


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

void ActionSpatialUnitSelectionPoint::InitAsDefaultInstance() {
  ::SC2APIProtocol::_ActionSpatialUnitSelectionPoint_default_instance_._instance.get_mutable()->selection_screen_coord_ = const_cast< ::SC2APIProtocol::PointI*>(
      ::SC2APIProtocol::PointI::internal_default_instance());
}
class ActionSpatialUnitSelectionPoint::_Internal {
 public:
  using HasBits = decltype(std::declval<ActionSpatialUnitSelectionPoint>()._has_bits_);
  static const ::SC2APIProtocol::PointI& selection_screen_coord(const ActionSpatialUnitSelectionPoint* msg);
  static void set_has_selection_screen_coord(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::SC2APIProtocol::PointI&
ActionSpatialUnitSelectionPoint::_Internal::selection_screen_coord(const ActionSpatialUnitSelectionPoint* msg) {
  return *msg->selection_screen_coord_;
}
void ActionSpatialUnitSelectionPoint::clear_selection_screen_coord() {
  if (selection_screen_coord_ != nullptr) selection_screen_coord_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
ActionSpatialUnitSelectionPoint::ActionSpatialUnitSelectionPoint()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionSpatialUnitSelectionPoint)
}
ActionSpatialUnitSelectionPoint::ActionSpatialUnitSelectionPoint(const ActionSpatialUnitSelectionPoint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from._internal_has_selection_screen_coord()) {
    selection_screen_coord_ = new ::SC2APIProtocol::PointI(*from.selection_screen_coord_);
  } else {
    selection_screen_coord_ = nullptr;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionSpatialUnitSelectionPoint)
}

void ActionSpatialUnitSelectionPoint::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionSpatialUnitSelectionPoint_s2clientprotocol_2fspatial_2eproto.base);
  selection_screen_coord_ = nullptr;
  type_ = 1;
}

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

void ActionSpatialUnitSelectionPoint::SharedDtor() {
  if (this != internal_default_instance()) delete selection_screen_coord_;
}

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


void ActionSpatialUnitSelectionPoint::Clear() {
// @@protoc_insertion_point(message_clear_start:SC2APIProtocol.ActionSpatialUnitSelectionPoint)
  ::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(selection_screen_coord_ != nullptr);
      selection_screen_coord_->Clear();
    }
    type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionSpatialUnitSelectionPoint::_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 selection_screen_coord = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_selection_screen_coord(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .SC2APIProtocol.ActionSpatialUnitSelectionPoint.Type type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::SC2APIProtocol::ActionSpatialUnitSelectionPoint_Type_IsValid(val))) {
            _internal_set_type(static_cast<::SC2APIProtocol::ActionSpatialUnitSelectionPoint_Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

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

  // optional .SC2APIProtocol.ActionSpatialUnitSelectionPoint.Type type = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_type(), 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.ActionSpatialUnitSelectionPoint)
  return target;
}

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

    // optional .SC2APIProtocol.ActionSpatialUnitSelectionPoint.Type type = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
    }

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

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

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

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

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

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

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


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

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

void ActionSpatialUnitSelectionRect::clear_selection_screen_coord() {
  selection_screen_coord_.Clear();
}
ActionSpatialUnitSelectionRect::ActionSpatialUnitSelectionRect()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SC2APIProtocol.ActionSpatialUnitSelectionRect)
}
ActionSpatialUnitSelectionRect::ActionSpatialUnitSelectionRect(const ActionSpatialUnitSelectionRect& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      selection_screen_coord_(from.selection_screen_coord_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  selection_add_ = from.selection_add_;
  // @@protoc_insertion_point(copy_constructor:SC2APIProtocol.ActionSpatialUnitSelectionRect)
}

void ActionSpatialUnitSelectionRect::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ActionSpatialUnitSelectionRect_s2clientprotocol_2fspatial_2eproto.base);
  selection_add_ = false;
}

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

void ActionSpatialUnitSelectionRect::SharedDtor() {
}

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


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

  selection_screen_coord_.Clear();
  selection_add_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* ActionSpatialUnitSelectionRect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .SC2APIProtocol.RectangleI selection_screen_coord = 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_selection_screen_coord(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bool selection_add = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_selection_add(&has_bits);
          selection_add_ = ::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* ActionSpatialUnitSelectionRect::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:SC2APIProtocol.ActionSpatialUnitSelectionRect)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  cached_has_bits = _has_bits_[0];
  // optional bool selection_add = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_selection_add(), 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.ActionSpatialUnitSelectionRect)
  return target;
}

size_t ActionSpatialUnitSelectionRect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:SC2APIProtocol.ActionSpatialUnitSelectionRect)
  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.RectangleI selection_screen_coord = 1;
  total_size += 1UL * this->_internal_selection_screen_coord_size();
  for (const auto& msg : this->selection_screen_coord_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional bool selection_add = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    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 ActionSpatialUnitSelectionRect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:SC2APIProtocol.ActionSpatialUnitSelectionRect)
  GOOGLE_DCHECK_NE(&from, this);
  const ActionSpatialUnitSelectionRect* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ActionSpatialUnitSelectionRect>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:SC2APIProtocol.ActionSpatialUnitSelectionRect)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:SC2APIProtocol.ActionSpatialUnitSelectionRect)
    MergeFrom(*source);
  }
}

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

  selection_screen_coord_.MergeFrom(from.selection_screen_coord_);
  if (from._internal_has_selection_add()) {
    _internal_set_selection_add(from._internal_selection_add());
  }
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace SC2APIProtocol
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ObservationFeatureLayer* Arena::CreateMaybeMessage< ::SC2APIProtocol::ObservationFeatureLayer >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ObservationFeatureLayer >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::FeatureLayers* Arena::CreateMaybeMessage< ::SC2APIProtocol::FeatureLayers >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::FeatureLayers >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::FeatureLayersMinimap* Arena::CreateMaybeMessage< ::SC2APIProtocol::FeatureLayersMinimap >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::FeatureLayersMinimap >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ObservationRender* Arena::CreateMaybeMessage< ::SC2APIProtocol::ObservationRender >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ObservationRender >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionSpatial* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionSpatial >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionSpatial >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionSpatialUnitCommand* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionSpatialUnitCommand >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionSpatialUnitCommand >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionSpatialCameraMove* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionSpatialCameraMove >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionSpatialCameraMove >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionSpatialUnitSelectionPoint* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionSpatialUnitSelectionPoint >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionSpatialUnitSelectionPoint >(arena);
}
template<> PROTOBUF_NOINLINE ::SC2APIProtocol::ActionSpatialUnitSelectionRect* Arena::CreateMaybeMessage< ::SC2APIProtocol::ActionSpatialUnitSelectionRect >(Arena* arena) {
  return Arena::CreateInternal< ::SC2APIProtocol::ActionSpatialUnitSelectionRect >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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