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

#include "fatdemo.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>

PROTOBUF_PRAGMA_INIT_SEG

namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;

PROTOBUF_CONSTEXPR MLDict::MLDict(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.val_string_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.val_int_)*/0
  , /*decltype(_impl_.val_float_)*/0} {}
struct MLDictDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLDictDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLDictDefaultTypeInternal() {}
  union {
    MLDict _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLDictDefaultTypeInternal _MLDict_default_instance_;
PROTOBUF_CONSTEXPR MLEvent::MLEvent(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/{}
  , /*decltype(_impl_.event_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
struct MLEventDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLEventDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLEventDefaultTypeInternal() {}
  union {
    MLEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLEventDefaultTypeInternal _MLEvent_default_instance_;
PROTOBUF_CONSTEXPR MLMatchState::MLMatchState(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.game_mode_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.phase_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.round_)*/0
  , /*decltype(_impl_.score_ct_)*/0
  , /*decltype(_impl_.score_t_)*/0} {}
struct MLMatchStateDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLMatchStateDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLMatchStateDefaultTypeInternal() {}
  union {
    MLMatchState _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLMatchStateDefaultTypeInternal _MLMatchState_default_instance_;
PROTOBUF_CONSTEXPR MLRoundState::MLRoundState(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.phase_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.bomb_state_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.win_team_)*/0} {}
struct MLRoundStateDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLRoundStateDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLRoundStateDefaultTypeInternal() {}
  union {
    MLRoundState _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLRoundStateDefaultTypeInternal _MLRoundState_default_instance_;
PROTOBUF_CONSTEXPR MLWeaponState::MLWeaponState(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.state_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.index_)*/0
  , /*decltype(_impl_.type_)*/0
  , /*decltype(_impl_.ammo_clip_)*/0
  , /*decltype(_impl_.ammo_clip_max_)*/0
  , /*decltype(_impl_.ammo_reserve_)*/0
  , /*decltype(_impl_.recoil_index_)*/0} {}
struct MLWeaponStateDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLWeaponStateDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLWeaponStateDefaultTypeInternal() {}
  union {
    MLWeaponState _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLWeaponStateDefaultTypeInternal _MLWeaponState_default_instance_;
PROTOBUF_CONSTEXPR MLPlayerState::MLPlayerState(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.weapons_)*/{}
  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.clan_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.abspos_)*/nullptr
  , /*decltype(_impl_.eyeangle_)*/nullptr
  , /*decltype(_impl_.eyeangle_fwd_)*/nullptr
  , /*decltype(_impl_.account_id_)*/0
  , /*decltype(_impl_.entindex_)*/0
  , /*decltype(_impl_.team_)*/0
  , /*decltype(_impl_.health_)*/0
  , /*decltype(_impl_.armor_)*/0
  , /*decltype(_impl_.flashed_)*/0
  , /*decltype(_impl_.smoked_)*/0
  , /*decltype(_impl_.money_)*/0
  , /*decltype(_impl_.round_kills_)*/0
  , /*decltype(_impl_.round_killhs_)*/0
  , /*decltype(_impl_.burning_)*/0
  , /*decltype(_impl_.helmet_)*/false
  , /*decltype(_impl_.defuse_kit_)*/false
  , /*decltype(_impl_.player_slot_)*/-1} {}
struct MLPlayerStateDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLPlayerStateDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLPlayerStateDefaultTypeInternal() {}
  union {
    MLPlayerState _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLPlayerStateDefaultTypeInternal _MLPlayerState_default_instance_;
PROTOBUF_CONSTEXPR MLGameState::MLGameState(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.players_)*/{}
  , /*decltype(_impl_.match_)*/nullptr
  , /*decltype(_impl_.round_)*/nullptr} {}
struct MLGameStateDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLGameStateDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLGameStateDefaultTypeInternal() {}
  union {
    MLGameState _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLGameStateDefaultTypeInternal _MLGameState_default_instance_;
PROTOBUF_CONSTEXPR MLDemoHeader::MLDemoHeader(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.map_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.tick_rate_)*/0
  , /*decltype(_impl_.version_)*/0u
  , /*decltype(_impl_.steam_universe_)*/0u} {}
struct MLDemoHeaderDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLDemoHeaderDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLDemoHeaderDefaultTypeInternal() {}
  union {
    MLDemoHeader _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLDemoHeaderDefaultTypeInternal _MLDemoHeader_default_instance_;
PROTOBUF_CONSTEXPR MLTick::MLTick(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.events_)*/{}
  , /*decltype(_impl_.state_)*/nullptr
  , /*decltype(_impl_.tick_count_)*/0} {}
struct MLTickDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MLTickDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~MLTickDefaultTypeInternal() {}
  union {
    MLTick _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MLTickDefaultTypeInternal _MLTick_default_instance_;
PROTOBUF_CONSTEXPR VacNetShot::VacNetShot(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.delta_yaw_window_)*/{}
  , /*decltype(_impl_.delta_pitch_window_)*/{}
  , /*decltype(_impl_.steamid_player_)*/uint64_t{0u}
  , /*decltype(_impl_.round_number_)*/0
  , /*decltype(_impl_.hit_type_)*/0
  , /*decltype(_impl_.weapon_type_)*/0
  , /*decltype(_impl_.distance_to_hurt_target_)*/0} {}
struct VacNetShotDefaultTypeInternal {
  PROTOBUF_CONSTEXPR VacNetShotDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~VacNetShotDefaultTypeInternal() {}
  union {
    VacNetShot _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VacNetShotDefaultTypeInternal _VacNetShot_default_instance_;
static ::_pb::Metadata file_level_metadata_fatdemo_2eproto[10];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_fatdemo_2eproto[3];
static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_fatdemo_2eproto = nullptr;

const uint32_t TableStruct_fatdemo_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::MLDict, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLDict, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLDict, _impl_.key_),
  PROTOBUF_FIELD_OFFSET(::MLDict, _impl_.val_string_),
  PROTOBUF_FIELD_OFFSET(::MLDict, _impl_.val_int_),
  PROTOBUF_FIELD_OFFSET(::MLDict, _impl_.val_float_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::MLEvent, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLEvent, _impl_.event_name_),
  PROTOBUF_FIELD_OFFSET(::MLEvent, _impl_.data_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _impl_.game_mode_),
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _impl_.phase_),
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _impl_.round_),
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _impl_.score_ct_),
  PROTOBUF_FIELD_OFFSET(::MLMatchState, _impl_.score_t_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::MLRoundState, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLRoundState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLRoundState, _impl_.phase_),
  PROTOBUF_FIELD_OFFSET(::MLRoundState, _impl_.win_team_),
  PROTOBUF_FIELD_OFFSET(::MLRoundState, _impl_.bomb_state_),
  0,
  2,
  1,
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.index_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.name_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.type_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.ammo_clip_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.ammo_clip_max_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.ammo_reserve_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.state_),
  PROTOBUF_FIELD_OFFSET(::MLWeaponState, _impl_.recoil_index_),
  2,
  0,
  3,
  4,
  5,
  6,
  1,
  7,
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.account_id_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.player_slot_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.entindex_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.name_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.clan_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.team_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.abspos_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.eyeangle_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.eyeangle_fwd_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.health_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.armor_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.flashed_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.smoked_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.money_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.round_kills_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.round_killhs_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.burning_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.helmet_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.defuse_kit_),
  PROTOBUF_FIELD_OFFSET(::MLPlayerState, _impl_.weapons_),
  5,
  18,
  6,
  0,
  1,
  7,
  2,
  3,
  4,
  8,
  9,
  10,
  11,
  12,
  13,
  14,
  15,
  16,
  17,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::MLGameState, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLGameState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLGameState, _impl_.match_),
  PROTOBUF_FIELD_OFFSET(::MLGameState, _impl_.round_),
  PROTOBUF_FIELD_OFFSET(::MLGameState, _impl_.players_),
  0,
  1,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::MLDemoHeader, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLDemoHeader, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLDemoHeader, _impl_.map_name_),
  PROTOBUF_FIELD_OFFSET(::MLDemoHeader, _impl_.tick_rate_),
  PROTOBUF_FIELD_OFFSET(::MLDemoHeader, _impl_.version_),
  PROTOBUF_FIELD_OFFSET(::MLDemoHeader, _impl_.steam_universe_),
  0,
  1,
  2,
  3,
  PROTOBUF_FIELD_OFFSET(::MLTick, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::MLTick, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::MLTick, _impl_.tick_count_),
  PROTOBUF_FIELD_OFFSET(::MLTick, _impl_.state_),
  PROTOBUF_FIELD_OFFSET(::MLTick, _impl_.events_),
  1,
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.steamid_player_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.round_number_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.hit_type_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.weapon_type_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.distance_to_hurt_target_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.delta_yaw_window_),
  PROTOBUF_FIELD_OFFSET(::VacNetShot, _impl_.delta_pitch_window_),
  0,
  1,
  2,
  3,
  4,
  ~0u,
  ~0u,
};
static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 10, -1, sizeof(::MLDict)},
  { 14, 22, -1, sizeof(::MLEvent)},
  { 24, 35, -1, sizeof(::MLMatchState)},
  { 40, 49, -1, sizeof(::MLRoundState)},
  { 52, 66, -1, sizeof(::MLWeaponState)},
  { 74, 100, -1, sizeof(::MLPlayerState)},
  { 120, 129, -1, sizeof(::MLGameState)},
  { 132, 142, -1, sizeof(::MLDemoHeader)},
  { 146, 155, -1, sizeof(::MLTick)},
  { 158, 171, -1, sizeof(::VacNetShot)},
};

static const ::_pb::Message* const file_default_instances[] = {
  &::_MLDict_default_instance_._instance,
  &::_MLEvent_default_instance_._instance,
  &::_MLMatchState_default_instance_._instance,
  &::_MLRoundState_default_instance_._instance,
  &::_MLWeaponState_default_instance_._instance,
  &::_MLPlayerState_default_instance_._instance,
  &::_MLGameState_default_instance_._instance,
  &::_MLDemoHeader_default_instance_._instance,
  &::_MLTick_default_instance_._instance,
  &::_VacNetShot_default_instance_._instance,
};

const char descriptor_table_protodef_fatdemo_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\rfatdemo.proto\032\026networkbasetypes.proto\""
  "M\n\006MLDict\022\013\n\003key\030\001 \001(\t\022\022\n\nval_string\030\002 \001"
  "(\t\022\017\n\007val_int\030\003 \001(\005\022\021\n\tval_float\030\004 \001(\002\"4"
  "\n\007MLEvent\022\022\n\nevent_name\030\001 \001(\t\022\025\n\004data\030\002 "
  "\003(\0132\007.MLDict\"b\n\014MLMatchState\022\021\n\tgame_mod"
  "e\030\001 \001(\t\022\r\n\005phase\030\002 \001(\t\022\r\n\005round\030\003 \001(\005\022\020\n"
  "\010score_ct\030\004 \001(\005\022\017\n\007score_t\030\005 \001(\005\"W\n\014MLRo"
  "undState\022\r\n\005phase\030\001 \001(\t\022$\n\010win_team\030\002 \001("
  "\0162\006.ETeam:\nET_Unknown\022\022\n\nbomb_state\030\003 \001("
  "\t\"\270\001\n\rMLWeaponState\022\r\n\005index\030\001 \001(\005\022\014\n\004na"
  "me\030\002 \001(\t\022%\n\004type\030\003 \001(\0162\014.EWeaponType:\tEW"
  "T_Knife\022\021\n\tammo_clip\030\004 \001(\005\022\025\n\rammo_clip_"
  "max\030\005 \001(\005\022\024\n\014ammo_reserve\030\006 \001(\005\022\r\n\005state"
  "\030\007 \001(\t\022\024\n\014recoil_index\030\010 \001(\002\"\273\003\n\rMLPlaye"
  "rState\022\022\n\naccount_id\030\001 \001(\005\022\027\n\013player_slo"
  "t\030\002 \001(\005:\002-1\022\020\n\010entindex\030\003 \001(\005\022\014\n\004name\030\004 "
  "\001(\t\022\014\n\004clan\030\005 \001(\t\022 \n\004team\030\006 \001(\0162\006.ETeam:"
  "\nET_Unknown\022\033\n\006abspos\030\007 \001(\0132\013.CMsgVector"
  "\022\035\n\010eyeangle\030\010 \001(\0132\013.CMsgQAngle\022!\n\014eyean"
  "gle_fwd\030\t \001(\0132\013.CMsgVector\022\016\n\006health\030\n \001"
  "(\005\022\r\n\005armor\030\013 \001(\005\022\017\n\007flashed\030\014 \001(\002\022\016\n\006sm"
  "oked\030\r \001(\002\022\r\n\005money\030\016 \001(\005\022\023\n\013round_kills"
  "\030\017 \001(\005\022\024\n\014round_killhs\030\020 \001(\005\022\017\n\007burning\030"
  "\021 \001(\002\022\016\n\006helmet\030\022 \001(\010\022\022\n\ndefuse_kit\030\023 \001("
  "\010\022\037\n\007weapons\030\024 \003(\0132\016.MLWeaponState\"j\n\013ML"
  "GameState\022\034\n\005match\030\001 \001(\0132\r.MLMatchState\022"
  "\034\n\005round\030\002 \001(\0132\r.MLRoundState\022\037\n\007players"
  "\030\003 \003(\0132\016.MLPlayerState\"\\\n\014MLDemoHeader\022\020"
  "\n\010map_name\030\001 \001(\t\022\021\n\ttick_rate\030\002 \001(\005\022\017\n\007v"
  "ersion\030\003 \001(\r\022\026\n\016steam_universe\030\004 \001(\r\"S\n\006"
  "MLTick\022\022\n\ntick_count\030\001 \001(\005\022\033\n\005state\030\002 \001("
  "\0132\014.MLGameState\022\030\n\006events\030\003 \003(\0132\010.MLEven"
  "t\"\270\001\n\nVacNetShot\022\026\n\016steamid_player\030\001 \001(\006"
  "\022\024\n\014round_number\030\002 \001(\005\022\020\n\010hit_type\030\003 \001(\005"
  "\022\023\n\013weapon_type\030\004 \001(\005\022\037\n\027distance_to_hur"
  "t_target\030\005 \001(\002\022\030\n\020delta_yaw_window\030\006 \003(\002"
  "\022\032\n\022delta_pitch_window\030\007 \003(\002*\254\001\n\tEHitGro"
  "up\022\017\n\013EHG_Generic\020\000\022\014\n\010EHG_Head\020\001\022\r\n\tEHG"
  "_Chest\020\002\022\017\n\013EHG_Stomach\020\003\022\017\n\013EHG_LeftArm"
  "\020\004\022\020\n\014EHG_RightArm\020\005\022\017\n\013EHG_LeftLeg\020\006\022\020\n"
  "\014EHG_RightLeg\020\007\022\014\n\010EHG_Gear\020\010\022\014\n\010EHG_Mis"
  "s\020\t*F\n\005ETeam\022\016\n\nET_Unknown\020\000\022\020\n\014ET_Spect"
  "ator\020\001\022\020\n\014ET_Terrorist\020\002\022\t\n\005ET_CT\020\003*\344\001\n\013"
  "EWeaponType\022\r\n\tEWT_Knife\020\000\022\016\n\nEWT_Pistol"
  "\020\001\022\025\n\021EWT_SubMachineGun\020\002\022\r\n\tEWT_Rifle\020\003"
  "\022\017\n\013EWT_Shotgun\020\004\022\023\n\017EWT_SniperRifle\020\005\022\022"
  "\n\016EWT_MachineGun\020\006\022\n\n\006EWT_C4\020\007\022\017\n\013EWT_Gr"
  "enade\020\010\022\021\n\rEWT_Equipment\020\t\022\025\n\021EWT_Stacka"
  "bleItem\020\n\022\017\n\013EWT_Unknown\020\013"
  ;
static const ::_pbi::DescriptorTable* const descriptor_table_fatdemo_2eproto_deps[1] = {
  &::descriptor_table_networkbasetypes_2eproto,
};
static ::_pbi::once_flag descriptor_table_fatdemo_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_fatdemo_2eproto = {
    false, false, 1946, descriptor_table_protodef_fatdemo_2eproto,
    "fatdemo.proto",
    &descriptor_table_fatdemo_2eproto_once, descriptor_table_fatdemo_2eproto_deps, 1, 10,
    schemas, file_default_instances, TableStruct_fatdemo_2eproto::offsets,
    file_level_metadata_fatdemo_2eproto, file_level_enum_descriptors_fatdemo_2eproto,
    file_level_service_descriptors_fatdemo_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_fatdemo_2eproto_getter() {
  return &descriptor_table_fatdemo_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_fatdemo_2eproto(&descriptor_table_fatdemo_2eproto);
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EHitGroup_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_fatdemo_2eproto);
  return file_level_enum_descriptors_fatdemo_2eproto[0];
}
bool EHitGroup_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ETeam_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_fatdemo_2eproto);
  return file_level_enum_descriptors_fatdemo_2eproto[1];
}
bool ETeam_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EWeaponType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_fatdemo_2eproto);
  return file_level_enum_descriptors_fatdemo_2eproto[2];
}
bool EWeaponType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
      return true;
    default:
      return false;
  }
}


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

class MLDict::_Internal {
 public:
  using HasBits = decltype(std::declval<MLDict>()._impl_._has_bits_);
  static void set_has_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_val_string(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_val_int(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_val_float(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

MLDict::MLDict(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLDict)
}
MLDict::MLDict(const MLDict& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLDict* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.key_){}
    , decltype(_impl_.val_string_){}
    , decltype(_impl_.val_int_){}
    , decltype(_impl_.val_float_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_key()) {
    _this->_impl_.key_.Set(from._internal_key(), 
      _this->GetArenaForAllocation());
  }
  _impl_.val_string_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.val_string_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_val_string()) {
    _this->_impl_.val_string_.Set(from._internal_val_string(), 
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.val_int_, &from._impl_.val_int_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.val_float_) -
    reinterpret_cast<char*>(&_impl_.val_int_)) + sizeof(_impl_.val_float_));
  // @@protoc_insertion_point(copy_constructor:MLDict)
}

inline void MLDict::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.key_){}
    , decltype(_impl_.val_string_){}
    , decltype(_impl_.val_int_){0}
    , decltype(_impl_.val_float_){0}
  };
  _impl_.key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.key_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.val_string_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.val_string_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLDict::~MLDict() {
  // @@protoc_insertion_point(destructor:MLDict)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLDict::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.key_.Destroy();
  _impl_.val_string_.Destroy();
}

void MLDict::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLDict::Clear() {
// @@protoc_insertion_point(message_clear_start:MLDict)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.key_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      _impl_.val_string_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x0000000cu) {
    ::memset(&_impl_.val_int_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.val_float_) -
        reinterpret_cast<char*>(&_impl_.val_int_)) + sizeof(_impl_.val_float_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLDict::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_key();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLDict.key");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional string val_string = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_val_string();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLDict.val_string");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional int32 val_int = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_val_int(&has_bits);
          _impl_.val_int_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional float val_float = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 37)) {
          _Internal::set_has_val_float(&has_bits);
          _impl_.val_float_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLDict::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLDict)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional int32 val_int = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_val_int(), target);
  }

  // optional float val_float = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(4, this->_internal_val_float(), target);
  }

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

size_t MLDict::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLDict)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

    // optional int32 val_int = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_val_int());
    }

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

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLDict::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLDict::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLDict::GetClassData() const { return &_class_data_; }


void MLDict::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLDict*>(&to_msg);
  auto& from = static_cast<const MLDict&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLDict)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_key(from._internal_key());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_set_val_string(from._internal_val_string());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.val_int_ = from._impl_.val_int_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.val_float_ = from._impl_.val_float_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLDict::InternalSwap(MLDict* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.key_, lhs_arena,
      &other->_impl_.key_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.val_string_, lhs_arena,
      &other->_impl_.val_string_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLDict, _impl_.val_float_)
      + sizeof(MLDict::_impl_.val_float_)
      - PROTOBUF_FIELD_OFFSET(MLDict, _impl_.val_int_)>(
          reinterpret_cast<char*>(&_impl_.val_int_),
          reinterpret_cast<char*>(&other->_impl_.val_int_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MLDict::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[0]);
}

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

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

MLEvent::MLEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLEvent)
}
MLEvent::MLEvent(const MLEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLEvent* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){from._impl_.data_}
    , decltype(_impl_.event_name_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.event_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.event_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_event_name()) {
    _this->_impl_.event_name_.Set(from._internal_event_name(), 
      _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:MLEvent)
}

inline void MLEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){arena}
    , decltype(_impl_.event_name_){}
  };
  _impl_.event_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.event_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLEvent::~MLEvent() {
  // @@protoc_insertion_point(destructor:MLEvent)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.data_.~RepeatedPtrField();
  _impl_.event_name_.Destroy();
}

void MLEvent::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:MLEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.data_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    _impl_.event_name_.ClearNonDefaultToEmpty();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string event_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_event_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLEvent.event_name");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // repeated .MLDict data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_data(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // repeated .MLDict data = 2;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_data_size()); i < n; i++) {
    const auto& repfield = this->_internal_data(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
  }

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

size_t MLEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .MLDict data = 2;
  total_size += 1UL * this->_internal_data_size();
  for (const auto& msg : this->_impl_.data_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLEvent::GetClassData() const { return &_class_data_; }


void MLEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLEvent*>(&to_msg);
  auto& from = static_cast<const MLEvent&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLEvent)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.data_.MergeFrom(from._impl_.data_);
  if (from._internal_has_event_name()) {
    _this->_internal_set_event_name(from._internal_event_name());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLEvent::InternalSwap(MLEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.data_.InternalSwap(&other->_impl_.data_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.event_name_, lhs_arena,
      &other->_impl_.event_name_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata MLEvent::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[1]);
}

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

class MLMatchState::_Internal {
 public:
  using HasBits = decltype(std::declval<MLMatchState>()._impl_._has_bits_);
  static void set_has_game_mode(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_phase(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_round(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_score_ct(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_score_t(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

MLMatchState::MLMatchState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLMatchState)
}
MLMatchState::MLMatchState(const MLMatchState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLMatchState* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.game_mode_){}
    , decltype(_impl_.phase_){}
    , decltype(_impl_.round_){}
    , decltype(_impl_.score_ct_){}
    , decltype(_impl_.score_t_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.game_mode_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.game_mode_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_game_mode()) {
    _this->_impl_.game_mode_.Set(from._internal_game_mode(), 
      _this->GetArenaForAllocation());
  }
  _impl_.phase_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.phase_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_phase()) {
    _this->_impl_.phase_.Set(from._internal_phase(), 
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.round_, &from._impl_.round_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.score_t_) -
    reinterpret_cast<char*>(&_impl_.round_)) + sizeof(_impl_.score_t_));
  // @@protoc_insertion_point(copy_constructor:MLMatchState)
}

inline void MLMatchState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.game_mode_){}
    , decltype(_impl_.phase_){}
    , decltype(_impl_.round_){0}
    , decltype(_impl_.score_ct_){0}
    , decltype(_impl_.score_t_){0}
  };
  _impl_.game_mode_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.game_mode_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.phase_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.phase_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLMatchState::~MLMatchState() {
  // @@protoc_insertion_point(destructor:MLMatchState)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLMatchState::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.game_mode_.Destroy();
  _impl_.phase_.Destroy();
}

void MLMatchState::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLMatchState::Clear() {
// @@protoc_insertion_point(message_clear_start:MLMatchState)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.game_mode_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      _impl_.phase_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&_impl_.round_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.score_t_) -
        reinterpret_cast<char*>(&_impl_.round_)) + sizeof(_impl_.score_t_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLMatchState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string game_mode = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_game_mode();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLMatchState.game_mode");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional string phase = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_phase();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLMatchState.phase");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional int32 round = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_round(&has_bits);
          _impl_.round_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 score_ct = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_score_ct(&has_bits);
          _impl_.score_ct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 score_t = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_score_t(&has_bits);
          _impl_.score_t_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLMatchState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLMatchState)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional int32 round = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_round(), target);
  }

  // optional int32 score_ct = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_score_ct(), target);
  }

  // optional int32 score_t = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_score_t(), target);
  }

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

size_t MLMatchState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLMatchState)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

    // optional int32 round = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_round());
    }

    // optional int32 score_ct = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_score_ct());
    }

    // optional int32 score_t = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_score_t());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLMatchState::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLMatchState::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLMatchState::GetClassData() const { return &_class_data_; }


void MLMatchState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLMatchState*>(&to_msg);
  auto& from = static_cast<const MLMatchState&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLMatchState)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_game_mode(from._internal_game_mode());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_set_phase(from._internal_phase());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.round_ = from._impl_.round_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.score_ct_ = from._impl_.score_ct_;
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_impl_.score_t_ = from._impl_.score_t_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLMatchState::InternalSwap(MLMatchState* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.game_mode_, lhs_arena,
      &other->_impl_.game_mode_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.phase_, lhs_arena,
      &other->_impl_.phase_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLMatchState, _impl_.score_t_)
      + sizeof(MLMatchState::_impl_.score_t_)
      - PROTOBUF_FIELD_OFFSET(MLMatchState, _impl_.round_)>(
          reinterpret_cast<char*>(&_impl_.round_),
          reinterpret_cast<char*>(&other->_impl_.round_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MLMatchState::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[2]);
}

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

class MLRoundState::_Internal {
 public:
  using HasBits = decltype(std::declval<MLRoundState>()._impl_._has_bits_);
  static void set_has_phase(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_win_team(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_bomb_state(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MLRoundState::MLRoundState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLRoundState)
}
MLRoundState::MLRoundState(const MLRoundState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLRoundState* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.phase_){}
    , decltype(_impl_.bomb_state_){}
    , decltype(_impl_.win_team_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.phase_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.phase_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_phase()) {
    _this->_impl_.phase_.Set(from._internal_phase(), 
      _this->GetArenaForAllocation());
  }
  _impl_.bomb_state_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.bomb_state_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_bomb_state()) {
    _this->_impl_.bomb_state_.Set(from._internal_bomb_state(), 
      _this->GetArenaForAllocation());
  }
  _this->_impl_.win_team_ = from._impl_.win_team_;
  // @@protoc_insertion_point(copy_constructor:MLRoundState)
}

inline void MLRoundState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.phase_){}
    , decltype(_impl_.bomb_state_){}
    , decltype(_impl_.win_team_){0}
  };
  _impl_.phase_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.phase_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.bomb_state_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.bomb_state_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLRoundState::~MLRoundState() {
  // @@protoc_insertion_point(destructor:MLRoundState)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLRoundState::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.phase_.Destroy();
  _impl_.bomb_state_.Destroy();
}

void MLRoundState::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLRoundState::Clear() {
// @@protoc_insertion_point(message_clear_start:MLRoundState)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.phase_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      _impl_.bomb_state_.ClearNonDefaultToEmpty();
    }
  }
  _impl_.win_team_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLRoundState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string phase = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_phase();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLRoundState.phase");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional .ETeam win_team = 2 [default = ET_Unknown];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::ETeam_IsValid(val))) {
            _internal_set_win_team(static_cast<::ETeam>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional string bomb_state = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_bomb_state();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLRoundState.bomb_state");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLRoundState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLRoundState)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .ETeam win_team = 2 [default = ET_Unknown];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      2, this->_internal_win_team(), target);
  }

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

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

size_t MLRoundState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLRoundState)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

    // optional .ETeam win_team = 2 [default = ET_Unknown];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::_pbi::WireFormatLite::EnumSize(this->_internal_win_team());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLRoundState::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLRoundState::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLRoundState::GetClassData() const { return &_class_data_; }


void MLRoundState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLRoundState*>(&to_msg);
  auto& from = static_cast<const MLRoundState&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLRoundState)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_phase(from._internal_phase());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_set_bomb_state(from._internal_bomb_state());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.win_team_ = from._impl_.win_team_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLRoundState::InternalSwap(MLRoundState* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.phase_, lhs_arena,
      &other->_impl_.phase_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.bomb_state_, lhs_arena,
      &other->_impl_.bomb_state_, rhs_arena
  );
  swap(_impl_.win_team_, other->_impl_.win_team_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MLRoundState::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[3]);
}

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

class MLWeaponState::_Internal {
 public:
  using HasBits = decltype(std::declval<MLWeaponState>()._impl_._has_bits_);
  static void set_has_index(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_ammo_clip(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_ammo_clip_max(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_ammo_reserve(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_recoil_index(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
};

MLWeaponState::MLWeaponState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLWeaponState)
}
MLWeaponState::MLWeaponState(const MLWeaponState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLWeaponState* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.name_){}
    , decltype(_impl_.state_){}
    , decltype(_impl_.index_){}
    , decltype(_impl_.type_){}
    , decltype(_impl_.ammo_clip_){}
    , decltype(_impl_.ammo_clip_max_){}
    , decltype(_impl_.ammo_reserve_){}
    , decltype(_impl_.recoil_index_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_name()) {
    _this->_impl_.name_.Set(from._internal_name(), 
      _this->GetArenaForAllocation());
  }
  _impl_.state_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.state_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_state()) {
    _this->_impl_.state_.Set(from._internal_state(), 
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.index_, &from._impl_.index_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.recoil_index_) -
    reinterpret_cast<char*>(&_impl_.index_)) + sizeof(_impl_.recoil_index_));
  // @@protoc_insertion_point(copy_constructor:MLWeaponState)
}

inline void MLWeaponState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.name_){}
    , decltype(_impl_.state_){}
    , decltype(_impl_.index_){0}
    , decltype(_impl_.type_){0}
    , decltype(_impl_.ammo_clip_){0}
    , decltype(_impl_.ammo_clip_max_){0}
    , decltype(_impl_.ammo_reserve_){0}
    , decltype(_impl_.recoil_index_){0}
  };
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.state_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.state_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLWeaponState::~MLWeaponState() {
  // @@protoc_insertion_point(destructor:MLWeaponState)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLWeaponState::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.name_.Destroy();
  _impl_.state_.Destroy();
}

void MLWeaponState::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLWeaponState::Clear() {
// @@protoc_insertion_point(message_clear_start:MLWeaponState)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      _impl_.state_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x000000fcu) {
    ::memset(&_impl_.index_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.recoil_index_) -
        reinterpret_cast<char*>(&_impl_.index_)) + sizeof(_impl_.recoil_index_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLWeaponState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_index(&has_bits);
          _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLWeaponState.name");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional .EWeaponType type = 3 [default = EWT_Knife];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::EWeaponType_IsValid(val))) {
            _internal_set_type(static_cast<::EWeaponType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional int32 ammo_clip = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_ammo_clip(&has_bits);
          _impl_.ammo_clip_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 ammo_clip_max = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_ammo_clip_max(&has_bits);
          _impl_.ammo_clip_max_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 ammo_reserve = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _Internal::set_has_ammo_reserve(&has_bits);
          _impl_.ammo_reserve_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string state = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          auto str = _internal_mutable_state();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLWeaponState.state");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional float recoil_index = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 69)) {
          _Internal::set_has_recoil_index(&has_bits);
          _impl_.recoil_index_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLWeaponState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLWeaponState)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional int32 index = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_index(), target);
  }

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

  // optional .EWeaponType type = 3 [default = EWT_Knife];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      3, this->_internal_type(), target);
  }

  // optional int32 ammo_clip = 4;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_ammo_clip(), target);
  }

  // optional int32 ammo_clip_max = 5;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_ammo_clip_max(), target);
  }

  // optional int32 ammo_reserve = 6;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_ammo_reserve(), target);
  }

  // optional string state = 7;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_state().data(), static_cast<int>(this->_internal_state().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MLWeaponState.state");
    target = stream->WriteStringMaybeAliased(
        7, this->_internal_state(), target);
  }

  // optional float recoil_index = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(8, this->_internal_recoil_index(), target);
  }

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

size_t MLWeaponState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLWeaponState)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

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

    // optional int32 index = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_index());
    }

    // optional .EWeaponType type = 3 [default = EWT_Knife];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
    }

    // optional int32 ammo_clip = 4;
    if (cached_has_bits & 0x00000010u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ammo_clip());
    }

    // optional int32 ammo_clip_max = 5;
    if (cached_has_bits & 0x00000020u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ammo_clip_max());
    }

    // optional int32 ammo_reserve = 6;
    if (cached_has_bits & 0x00000040u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ammo_reserve());
    }

    // optional float recoil_index = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 4;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLWeaponState::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLWeaponState::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLWeaponState::GetClassData() const { return &_class_data_; }


void MLWeaponState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLWeaponState*>(&to_msg);
  auto& from = static_cast<const MLWeaponState&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLWeaponState)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_set_state(from._internal_state());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.index_ = from._impl_.index_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.type_ = from._impl_.type_;
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_impl_.ammo_clip_ = from._impl_.ammo_clip_;
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_impl_.ammo_clip_max_ = from._impl_.ammo_clip_max_;
    }
    if (cached_has_bits & 0x00000040u) {
      _this->_impl_.ammo_reserve_ = from._impl_.ammo_reserve_;
    }
    if (cached_has_bits & 0x00000080u) {
      _this->_impl_.recoil_index_ = from._impl_.recoil_index_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLWeaponState::InternalSwap(MLWeaponState* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.name_, lhs_arena,
      &other->_impl_.name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.state_, lhs_arena,
      &other->_impl_.state_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLWeaponState, _impl_.recoil_index_)
      + sizeof(MLWeaponState::_impl_.recoil_index_)
      - PROTOBUF_FIELD_OFFSET(MLWeaponState, _impl_.index_)>(
          reinterpret_cast<char*>(&_impl_.index_),
          reinterpret_cast<char*>(&other->_impl_.index_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MLWeaponState::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[4]);
}

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

class MLPlayerState::_Internal {
 public:
  using HasBits = decltype(std::declval<MLPlayerState>()._impl_._has_bits_);
  static void set_has_account_id(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_player_slot(HasBits* has_bits) {
    (*has_bits)[0] |= 262144u;
  }
  static void set_has_entindex(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_clan(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_team(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static const ::CMsgVector& abspos(const MLPlayerState* msg);
  static void set_has_abspos(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::CMsgQAngle& eyeangle(const MLPlayerState* msg);
  static void set_has_eyeangle(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::CMsgVector& eyeangle_fwd(const MLPlayerState* msg);
  static void set_has_eyeangle_fwd(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_health(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_armor(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_flashed(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_smoked(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_money(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_round_kills(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_round_killhs(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static void set_has_burning(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static void set_has_helmet(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static void set_has_defuse_kit(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
};

const ::CMsgVector&
MLPlayerState::_Internal::abspos(const MLPlayerState* msg) {
  return *msg->_impl_.abspos_;
}
const ::CMsgQAngle&
MLPlayerState::_Internal::eyeangle(const MLPlayerState* msg) {
  return *msg->_impl_.eyeangle_;
}
const ::CMsgVector&
MLPlayerState::_Internal::eyeangle_fwd(const MLPlayerState* msg) {
  return *msg->_impl_.eyeangle_fwd_;
}
void MLPlayerState::clear_abspos() {
  if (_impl_.abspos_ != nullptr) _impl_.abspos_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void MLPlayerState::clear_eyeangle() {
  if (_impl_.eyeangle_ != nullptr) _impl_.eyeangle_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
void MLPlayerState::clear_eyeangle_fwd() {
  if (_impl_.eyeangle_fwd_ != nullptr) _impl_.eyeangle_fwd_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
MLPlayerState::MLPlayerState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLPlayerState)
}
MLPlayerState::MLPlayerState(const MLPlayerState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLPlayerState* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.weapons_){from._impl_.weapons_}
    , decltype(_impl_.name_){}
    , decltype(_impl_.clan_){}
    , decltype(_impl_.abspos_){nullptr}
    , decltype(_impl_.eyeangle_){nullptr}
    , decltype(_impl_.eyeangle_fwd_){nullptr}
    , decltype(_impl_.account_id_){}
    , decltype(_impl_.entindex_){}
    , decltype(_impl_.team_){}
    , decltype(_impl_.health_){}
    , decltype(_impl_.armor_){}
    , decltype(_impl_.flashed_){}
    , decltype(_impl_.smoked_){}
    , decltype(_impl_.money_){}
    , decltype(_impl_.round_kills_){}
    , decltype(_impl_.round_killhs_){}
    , decltype(_impl_.burning_){}
    , decltype(_impl_.helmet_){}
    , decltype(_impl_.defuse_kit_){}
    , decltype(_impl_.player_slot_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_name()) {
    _this->_impl_.name_.Set(from._internal_name(), 
      _this->GetArenaForAllocation());
  }
  _impl_.clan_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.clan_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_clan()) {
    _this->_impl_.clan_.Set(from._internal_clan(), 
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_abspos()) {
    _this->_impl_.abspos_ = new ::CMsgVector(*from._impl_.abspos_);
  }
  if (from._internal_has_eyeangle()) {
    _this->_impl_.eyeangle_ = new ::CMsgQAngle(*from._impl_.eyeangle_);
  }
  if (from._internal_has_eyeangle_fwd()) {
    _this->_impl_.eyeangle_fwd_ = new ::CMsgVector(*from._impl_.eyeangle_fwd_);
  }
  ::memcpy(&_impl_.account_id_, &from._impl_.account_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.player_slot_) -
    reinterpret_cast<char*>(&_impl_.account_id_)) + sizeof(_impl_.player_slot_));
  // @@protoc_insertion_point(copy_constructor:MLPlayerState)
}

inline void MLPlayerState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.weapons_){arena}
    , decltype(_impl_.name_){}
    , decltype(_impl_.clan_){}
    , decltype(_impl_.abspos_){nullptr}
    , decltype(_impl_.eyeangle_){nullptr}
    , decltype(_impl_.eyeangle_fwd_){nullptr}
    , decltype(_impl_.account_id_){0}
    , decltype(_impl_.entindex_){0}
    , decltype(_impl_.team_){0}
    , decltype(_impl_.health_){0}
    , decltype(_impl_.armor_){0}
    , decltype(_impl_.flashed_){0}
    , decltype(_impl_.smoked_){0}
    , decltype(_impl_.money_){0}
    , decltype(_impl_.round_kills_){0}
    , decltype(_impl_.round_killhs_){0}
    , decltype(_impl_.burning_){0}
    , decltype(_impl_.helmet_){false}
    , decltype(_impl_.defuse_kit_){false}
    , decltype(_impl_.player_slot_){-1}
  };
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.clan_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.clan_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLPlayerState::~MLPlayerState() {
  // @@protoc_insertion_point(destructor:MLPlayerState)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLPlayerState::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.weapons_.~RepeatedPtrField();
  _impl_.name_.Destroy();
  _impl_.clan_.Destroy();
  if (this != internal_default_instance()) delete _impl_.abspos_;
  if (this != internal_default_instance()) delete _impl_.eyeangle_;
  if (this != internal_default_instance()) delete _impl_.eyeangle_fwd_;
}

void MLPlayerState::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLPlayerState::Clear() {
// @@protoc_insertion_point(message_clear_start:MLPlayerState)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.weapons_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      _impl_.clan_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(_impl_.abspos_ != nullptr);
      _impl_.abspos_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(_impl_.eyeangle_ != nullptr);
      _impl_.eyeangle_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      GOOGLE_DCHECK(_impl_.eyeangle_fwd_ != nullptr);
      _impl_.eyeangle_fwd_->Clear();
    }
  }
  if (cached_has_bits & 0x000000e0u) {
    ::memset(&_impl_.account_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.team_) -
        reinterpret_cast<char*>(&_impl_.account_id_)) + sizeof(_impl_.team_));
  }
  if (cached_has_bits & 0x0000ff00u) {
    ::memset(&_impl_.health_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.burning_) -
        reinterpret_cast<char*>(&_impl_.health_)) + sizeof(_impl_.burning_));
  }
  if (cached_has_bits & 0x00070000u) {
    ::memset(&_impl_.helmet_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.defuse_kit_) -
        reinterpret_cast<char*>(&_impl_.helmet_)) + sizeof(_impl_.defuse_kit_));
    _impl_.player_slot_ = -1;
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLPlayerState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 account_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_account_id(&has_bits);
          _impl_.account_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 player_slot = 2 [default = -1];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_player_slot(&has_bits);
          _impl_.player_slot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 entindex = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_entindex(&has_bits);
          _impl_.entindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string name = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLPlayerState.name");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional string clan = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          auto str = _internal_mutable_clan();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLPlayerState.clan");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional .ETeam team = 6 [default = ET_Unknown];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::ETeam_IsValid(val))) {
            _internal_set_team(static_cast<::ETeam>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgVector abspos = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_abspos(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgQAngle eyeangle = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_eyeangle(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgVector eyeangle_fwd = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_eyeangle_fwd(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 health = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
          _Internal::set_has_health(&has_bits);
          _impl_.health_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 armor = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _Internal::set_has_armor(&has_bits);
          _impl_.armor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional float flashed = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 101)) {
          _Internal::set_has_flashed(&has_bits);
          _impl_.flashed_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      // optional float smoked = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 109)) {
          _Internal::set_has_smoked(&has_bits);
          _impl_.smoked_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      // optional int32 money = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _Internal::set_has_money(&has_bits);
          _impl_.money_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 round_kills = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
          _Internal::set_has_round_kills(&has_bits);
          _impl_.round_kills_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 round_killhs = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _Internal::set_has_round_killhs(&has_bits);
          _impl_.round_killhs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional float burning = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 141)) {
          _Internal::set_has_burning(&has_bits);
          _impl_.burning_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      // optional bool helmet = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
          _Internal::set_has_helmet(&has_bits);
          _impl_.helmet_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool defuse_kit = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
          _Internal::set_has_defuse_kit(&has_bits);
          _impl_.defuse_kit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .MLWeaponState weapons = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
          ptr -= 2;
          do {
            ptr += 2;
            ptr = ctx->ParseMessage(_internal_add_weapons(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLPlayerState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLPlayerState)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional int32 account_id = 1;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_account_id(), target);
  }

  // optional int32 player_slot = 2 [default = -1];
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_player_slot(), target);
  }

  // optional int32 entindex = 3;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_entindex(), target);
  }

  // optional string name = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MLPlayerState.name");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_name(), target);
  }

  // optional string clan = 5;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_clan().data(), static_cast<int>(this->_internal_clan().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MLPlayerState.clan");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_clan(), target);
  }

  // optional .ETeam team = 6 [default = ET_Unknown];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
      6, this->_internal_team(), target);
  }

  // optional .CMsgVector abspos = 7;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, _Internal::abspos(this),
        _Internal::abspos(this).GetCachedSize(), target, stream);
  }

  // optional .CMsgQAngle eyeangle = 8;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, _Internal::eyeangle(this),
        _Internal::eyeangle(this).GetCachedSize(), target, stream);
  }

  // optional .CMsgVector eyeangle_fwd = 9;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(9, _Internal::eyeangle_fwd(this),
        _Internal::eyeangle_fwd(this).GetCachedSize(), target, stream);
  }

  // optional int32 health = 10;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(10, this->_internal_health(), target);
  }

  // optional int32 armor = 11;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(11, this->_internal_armor(), target);
  }

  // optional float flashed = 12;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(12, this->_internal_flashed(), target);
  }

  // optional float smoked = 13;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(13, this->_internal_smoked(), target);
  }

  // optional int32 money = 14;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(14, this->_internal_money(), target);
  }

  // optional int32 round_kills = 15;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(15, this->_internal_round_kills(), target);
  }

  // optional int32 round_killhs = 16;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(16, this->_internal_round_killhs(), target);
  }

  // optional float burning = 17;
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(17, this->_internal_burning(), target);
  }

  // optional bool helmet = 18;
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_helmet(), target);
  }

  // optional bool defuse_kit = 19;
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(19, this->_internal_defuse_kit(), target);
  }

  // repeated .MLWeaponState weapons = 20;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_weapons_size()); i < n; i++) {
    const auto& repfield = this->_internal_weapons(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(20, repfield, repfield.GetCachedSize(), target, stream);
  }

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

size_t MLPlayerState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLPlayerState)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .MLWeaponState weapons = 20;
  total_size += 2UL * this->_internal_weapons_size();
  for (const auto& msg : this->_impl_.weapons_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string name = 4;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

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

    // optional .CMsgVector abspos = 7;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.abspos_);
    }

    // optional .CMsgQAngle eyeangle = 8;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.eyeangle_);
    }

    // optional .CMsgVector eyeangle_fwd = 9;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.eyeangle_fwd_);
    }

    // optional int32 account_id = 1;
    if (cached_has_bits & 0x00000020u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_account_id());
    }

    // optional int32 entindex = 3;
    if (cached_has_bits & 0x00000040u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_entindex());
    }

    // optional .ETeam team = 6 [default = ET_Unknown];
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::_pbi::WireFormatLite::EnumSize(this->_internal_team());
    }

  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional int32 health = 10;
    if (cached_has_bits & 0x00000100u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_health());
    }

    // optional int32 armor = 11;
    if (cached_has_bits & 0x00000200u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_armor());
    }

    // optional float flashed = 12;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 + 4;
    }

    // optional float smoked = 13;
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 + 4;
    }

    // optional int32 money = 14;
    if (cached_has_bits & 0x00001000u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_money());
    }

    // optional int32 round_kills = 15;
    if (cached_has_bits & 0x00002000u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_round_kills());
    }

    // optional int32 round_killhs = 16;
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 +
        ::_pbi::WireFormatLite::Int32Size(
          this->_internal_round_killhs());
    }

    // optional float burning = 17;
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 + 4;
    }

  }
  if (cached_has_bits & 0x00070000u) {
    // optional bool helmet = 18;
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 + 1;
    }

    // optional bool defuse_kit = 19;
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 + 1;
    }

    // optional int32 player_slot = 2 [default = -1];
    if (cached_has_bits & 0x00040000u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_player_slot());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLPlayerState::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLPlayerState::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLPlayerState::GetClassData() const { return &_class_data_; }


void MLPlayerState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLPlayerState*>(&to_msg);
  auto& from = static_cast<const MLPlayerState&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLPlayerState)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.weapons_.MergeFrom(from._impl_.weapons_);
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_set_clan(from._internal_clan());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_abspos()->::CMsgVector::MergeFrom(
          from._internal_abspos());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_eyeangle()->::CMsgQAngle::MergeFrom(
          from._internal_eyeangle());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_internal_mutable_eyeangle_fwd()->::CMsgVector::MergeFrom(
          from._internal_eyeangle_fwd());
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_impl_.account_id_ = from._impl_.account_id_;
    }
    if (cached_has_bits & 0x00000040u) {
      _this->_impl_.entindex_ = from._impl_.entindex_;
    }
    if (cached_has_bits & 0x00000080u) {
      _this->_impl_.team_ = from._impl_.team_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      _this->_impl_.health_ = from._impl_.health_;
    }
    if (cached_has_bits & 0x00000200u) {
      _this->_impl_.armor_ = from._impl_.armor_;
    }
    if (cached_has_bits & 0x00000400u) {
      _this->_impl_.flashed_ = from._impl_.flashed_;
    }
    if (cached_has_bits & 0x00000800u) {
      _this->_impl_.smoked_ = from._impl_.smoked_;
    }
    if (cached_has_bits & 0x00001000u) {
      _this->_impl_.money_ = from._impl_.money_;
    }
    if (cached_has_bits & 0x00002000u) {
      _this->_impl_.round_kills_ = from._impl_.round_kills_;
    }
    if (cached_has_bits & 0x00004000u) {
      _this->_impl_.round_killhs_ = from._impl_.round_killhs_;
    }
    if (cached_has_bits & 0x00008000u) {
      _this->_impl_.burning_ = from._impl_.burning_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00070000u) {
    if (cached_has_bits & 0x00010000u) {
      _this->_impl_.helmet_ = from._impl_.helmet_;
    }
    if (cached_has_bits & 0x00020000u) {
      _this->_impl_.defuse_kit_ = from._impl_.defuse_kit_;
    }
    if (cached_has_bits & 0x00040000u) {
      _this->_impl_.player_slot_ = from._impl_.player_slot_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLPlayerState::InternalSwap(MLPlayerState* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.weapons_.InternalSwap(&other->_impl_.weapons_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.name_, lhs_arena,
      &other->_impl_.name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.clan_, lhs_arena,
      &other->_impl_.clan_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLPlayerState, _impl_.defuse_kit_)
      + sizeof(MLPlayerState::_impl_.defuse_kit_)
      - PROTOBUF_FIELD_OFFSET(MLPlayerState, _impl_.abspos_)>(
          reinterpret_cast<char*>(&_impl_.abspos_),
          reinterpret_cast<char*>(&other->_impl_.abspos_));
  swap(_impl_.player_slot_, other->_impl_.player_slot_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MLPlayerState::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[5]);
}

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

class MLGameState::_Internal {
 public:
  using HasBits = decltype(std::declval<MLGameState>()._impl_._has_bits_);
  static const ::MLMatchState& match(const MLGameState* msg);
  static void set_has_match(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::MLRoundState& round(const MLGameState* msg);
  static void set_has_round(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::MLMatchState&
MLGameState::_Internal::match(const MLGameState* msg) {
  return *msg->_impl_.match_;
}
const ::MLRoundState&
MLGameState::_Internal::round(const MLGameState* msg) {
  return *msg->_impl_.round_;
}
MLGameState::MLGameState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLGameState)
}
MLGameState::MLGameState(const MLGameState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLGameState* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.players_){from._impl_.players_}
    , decltype(_impl_.match_){nullptr}
    , decltype(_impl_.round_){nullptr}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_match()) {
    _this->_impl_.match_ = new ::MLMatchState(*from._impl_.match_);
  }
  if (from._internal_has_round()) {
    _this->_impl_.round_ = new ::MLRoundState(*from._impl_.round_);
  }
  // @@protoc_insertion_point(copy_constructor:MLGameState)
}

inline void MLGameState::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.players_){arena}
    , decltype(_impl_.match_){nullptr}
    , decltype(_impl_.round_){nullptr}
  };
}

MLGameState::~MLGameState() {
  // @@protoc_insertion_point(destructor:MLGameState)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLGameState::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.players_.~RepeatedPtrField();
  if (this != internal_default_instance()) delete _impl_.match_;
  if (this != internal_default_instance()) delete _impl_.round_;
}

void MLGameState::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLGameState::Clear() {
// @@protoc_insertion_point(message_clear_start:MLGameState)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.players_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(_impl_.match_ != nullptr);
      _impl_.match_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(_impl_.round_ != nullptr);
      _impl_.round_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLGameState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .MLMatchState match = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_match(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .MLRoundState round = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_round(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .MLPlayerState players = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_players(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLGameState::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLGameState)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional .MLMatchState match = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::match(this),
        _Internal::match(this).GetCachedSize(), target, stream);
  }

  // optional .MLRoundState round = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::round(this),
        _Internal::round(this).GetCachedSize(), target, stream);
  }

  // repeated .MLPlayerState players = 3;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_players_size()); i < n; i++) {
    const auto& repfield = this->_internal_players(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
  }

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

size_t MLGameState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLGameState)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .MLPlayerState players = 3;
  total_size += 1UL * this->_internal_players_size();
  for (const auto& msg : this->_impl_.players_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .MLMatchState match = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.match_);
    }

    // optional .MLRoundState round = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.round_);
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLGameState::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLGameState::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLGameState::GetClassData() const { return &_class_data_; }


void MLGameState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLGameState*>(&to_msg);
  auto& from = static_cast<const MLGameState&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLGameState)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.players_.MergeFrom(from._impl_.players_);
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_match()->::MLMatchState::MergeFrom(
          from._internal_match());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_round()->::MLRoundState::MergeFrom(
          from._internal_round());
    }
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLGameState::InternalSwap(MLGameState* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.players_.InternalSwap(&other->_impl_.players_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLGameState, _impl_.round_)
      + sizeof(MLGameState::_impl_.round_)
      - PROTOBUF_FIELD_OFFSET(MLGameState, _impl_.match_)>(
          reinterpret_cast<char*>(&_impl_.match_),
          reinterpret_cast<char*>(&other->_impl_.match_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MLGameState::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[6]);
}

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

class MLDemoHeader::_Internal {
 public:
  using HasBits = decltype(std::declval<MLDemoHeader>()._impl_._has_bits_);
  static void set_has_map_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_tick_rate(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_version(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_steam_universe(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

MLDemoHeader::MLDemoHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLDemoHeader)
}
MLDemoHeader::MLDemoHeader(const MLDemoHeader& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLDemoHeader* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.map_name_){}
    , decltype(_impl_.tick_rate_){}
    , decltype(_impl_.version_){}
    , decltype(_impl_.steam_universe_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.map_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.map_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_map_name()) {
    _this->_impl_.map_name_.Set(from._internal_map_name(), 
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.tick_rate_, &from._impl_.tick_rate_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.steam_universe_) -
    reinterpret_cast<char*>(&_impl_.tick_rate_)) + sizeof(_impl_.steam_universe_));
  // @@protoc_insertion_point(copy_constructor:MLDemoHeader)
}

inline void MLDemoHeader::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.map_name_){}
    , decltype(_impl_.tick_rate_){0}
    , decltype(_impl_.version_){0u}
    , decltype(_impl_.steam_universe_){0u}
  };
  _impl_.map_name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.map_name_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

MLDemoHeader::~MLDemoHeader() {
  // @@protoc_insertion_point(destructor:MLDemoHeader)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLDemoHeader::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.map_name_.Destroy();
}

void MLDemoHeader::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLDemoHeader::Clear() {
// @@protoc_insertion_point(message_clear_start:MLDemoHeader)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    _impl_.map_name_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&_impl_.tick_rate_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.steam_universe_) -
        reinterpret_cast<char*>(&_impl_.tick_rate_)) + sizeof(_impl_.steam_universe_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLDemoHeader::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string map_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_map_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "MLDemoHeader.map_name");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional int32 tick_rate = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_tick_rate(&has_bits);
          _impl_.tick_rate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 version = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_version(&has_bits);
          _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 steam_universe = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_steam_universe(&has_bits);
          _impl_.steam_universe_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLDemoHeader::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLDemoHeader)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional int32 tick_rate = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_tick_rate(), target);
  }

  // optional uint32 version = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_version(), target);
  }

  // optional uint32 steam_universe = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_steam_universe(), target);
  }

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

size_t MLDemoHeader::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLDemoHeader)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

    // optional int32 tick_rate = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_tick_rate());
    }

    // optional uint32 version = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_version());
    }

    // optional uint32 steam_universe = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_steam_universe());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLDemoHeader::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLDemoHeader::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLDemoHeader::GetClassData() const { return &_class_data_; }


void MLDemoHeader::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLDemoHeader*>(&to_msg);
  auto& from = static_cast<const MLDemoHeader&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLDemoHeader)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_map_name(from._internal_map_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.tick_rate_ = from._impl_.tick_rate_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.version_ = from._impl_.version_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.steam_universe_ = from._impl_.steam_universe_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLDemoHeader::InternalSwap(MLDemoHeader* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.map_name_, lhs_arena,
      &other->_impl_.map_name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLDemoHeader, _impl_.steam_universe_)
      + sizeof(MLDemoHeader::_impl_.steam_universe_)
      - PROTOBUF_FIELD_OFFSET(MLDemoHeader, _impl_.tick_rate_)>(
          reinterpret_cast<char*>(&_impl_.tick_rate_),
          reinterpret_cast<char*>(&other->_impl_.tick_rate_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MLDemoHeader::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[7]);
}

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

class MLTick::_Internal {
 public:
  using HasBits = decltype(std::declval<MLTick>()._impl_._has_bits_);
  static void set_has_tick_count(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::MLGameState& state(const MLTick* msg);
  static void set_has_state(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::MLGameState&
MLTick::_Internal::state(const MLTick* msg) {
  return *msg->_impl_.state_;
}
MLTick::MLTick(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:MLTick)
}
MLTick::MLTick(const MLTick& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  MLTick* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.events_){from._impl_.events_}
    , decltype(_impl_.state_){nullptr}
    , decltype(_impl_.tick_count_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_state()) {
    _this->_impl_.state_ = new ::MLGameState(*from._impl_.state_);
  }
  _this->_impl_.tick_count_ = from._impl_.tick_count_;
  // @@protoc_insertion_point(copy_constructor:MLTick)
}

inline void MLTick::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.events_){arena}
    , decltype(_impl_.state_){nullptr}
    , decltype(_impl_.tick_count_){0}
  };
}

MLTick::~MLTick() {
  // @@protoc_insertion_point(destructor:MLTick)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void MLTick::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.events_.~RepeatedPtrField();
  if (this != internal_default_instance()) delete _impl_.state_;
}

void MLTick::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void MLTick::Clear() {
// @@protoc_insertion_point(message_clear_start:MLTick)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.events_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(_impl_.state_ != nullptr);
    _impl_.state_->Clear();
  }
  _impl_.tick_count_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MLTick::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 tick_count = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_tick_count(&has_bits);
          _impl_.tick_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .MLGameState state = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_state(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated .MLEvent events = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_events(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MLTick::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MLTick)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional int32 tick_count = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_tick_count(), target);
  }

  // optional .MLGameState state = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::state(this),
        _Internal::state(this).GetCachedSize(), target, stream);
  }

  // repeated .MLEvent events = 3;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_events_size()); i < n; i++) {
    const auto& repfield = this->_internal_events(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
  }

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

size_t MLTick::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MLTick)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .MLEvent events = 3;
  total_size += 1UL * this->_internal_events_size();
  for (const auto& msg : this->_impl_.events_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .MLGameState state = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.state_);
    }

    // optional int32 tick_count = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_tick_count());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MLTick::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    MLTick::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MLTick::GetClassData() const { return &_class_data_; }


void MLTick::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<MLTick*>(&to_msg);
  auto& from = static_cast<const MLTick&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:MLTick)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.events_.MergeFrom(from._impl_.events_);
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_state()->::MLGameState::MergeFrom(
          from._internal_state());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.tick_count_ = from._impl_.tick_count_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void MLTick::InternalSwap(MLTick* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.events_.InternalSwap(&other->_impl_.events_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MLTick, _impl_.tick_count_)
      + sizeof(MLTick::_impl_.tick_count_)
      - PROTOBUF_FIELD_OFFSET(MLTick, _impl_.state_)>(
          reinterpret_cast<char*>(&_impl_.state_),
          reinterpret_cast<char*>(&other->_impl_.state_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MLTick::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[8]);
}

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

class VacNetShot::_Internal {
 public:
  using HasBits = decltype(std::declval<VacNetShot>()._impl_._has_bits_);
  static void set_has_steamid_player(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_round_number(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_hit_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_weapon_type(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_distance_to_hurt_target(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

VacNetShot::VacNetShot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:VacNetShot)
}
VacNetShot::VacNetShot(const VacNetShot& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  VacNetShot* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.delta_yaw_window_){from._impl_.delta_yaw_window_}
    , decltype(_impl_.delta_pitch_window_){from._impl_.delta_pitch_window_}
    , decltype(_impl_.steamid_player_){}
    , decltype(_impl_.round_number_){}
    , decltype(_impl_.hit_type_){}
    , decltype(_impl_.weapon_type_){}
    , decltype(_impl_.distance_to_hurt_target_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&_impl_.steamid_player_, &from._impl_.steamid_player_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.distance_to_hurt_target_) -
    reinterpret_cast<char*>(&_impl_.steamid_player_)) + sizeof(_impl_.distance_to_hurt_target_));
  // @@protoc_insertion_point(copy_constructor:VacNetShot)
}

inline void VacNetShot::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.delta_yaw_window_){arena}
    , decltype(_impl_.delta_pitch_window_){arena}
    , decltype(_impl_.steamid_player_){uint64_t{0u}}
    , decltype(_impl_.round_number_){0}
    , decltype(_impl_.hit_type_){0}
    , decltype(_impl_.weapon_type_){0}
    , decltype(_impl_.distance_to_hurt_target_){0}
  };
}

VacNetShot::~VacNetShot() {
  // @@protoc_insertion_point(destructor:VacNetShot)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void VacNetShot::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.delta_yaw_window_.~RepeatedField();
  _impl_.delta_pitch_window_.~RepeatedField();
}

void VacNetShot::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void VacNetShot::Clear() {
// @@protoc_insertion_point(message_clear_start:VacNetShot)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.delta_yaw_window_.Clear();
  _impl_.delta_pitch_window_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&_impl_.steamid_player_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.distance_to_hurt_target_) -
        reinterpret_cast<char*>(&_impl_.steamid_player_)) + sizeof(_impl_.distance_to_hurt_target_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* VacNetShot::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional fixed64 steamid_player = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
          _Internal::set_has_steamid_player(&has_bits);
          _impl_.steamid_player_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional int32 round_number = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_round_number(&has_bits);
          _impl_.round_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 hit_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_hit_type(&has_bits);
          _impl_.hit_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 weapon_type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_weapon_type(&has_bits);
          _impl_.weapon_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional float distance_to_hurt_target = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 45)) {
          _Internal::set_has_distance_to_hurt_target(&has_bits);
          _impl_.distance_to_hurt_target_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else
          goto handle_unusual;
        continue;
      // repeated float delta_yaw_window = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 53)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_delta_yaw_window(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
            ptr += sizeof(float);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<53>(ptr));
        } else if (static_cast<uint8_t>(tag) == 50) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_delta_yaw_window(), ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated float delta_pitch_window = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 61)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_delta_pitch_window(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
            ptr += sizeof(float);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr));
        } else if (static_cast<uint8_t>(tag) == 58) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_delta_pitch_window(), ptr, ctx);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* VacNetShot::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:VacNetShot)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional fixed64 steamid_player = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(1, this->_internal_steamid_player(), target);
  }

  // optional int32 round_number = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_round_number(), target);
  }

  // optional int32 hit_type = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_hit_type(), target);
  }

  // optional int32 weapon_type = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_weapon_type(), target);
  }

  // optional float distance_to_hurt_target = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(5, this->_internal_distance_to_hurt_target(), target);
  }

  // repeated float delta_yaw_window = 6;
  for (int i = 0, n = this->_internal_delta_yaw_window_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(6, this->_internal_delta_yaw_window(i), target);
  }

  // repeated float delta_pitch_window = 7;
  for (int i = 0, n = this->_internal_delta_pitch_window_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(7, this->_internal_delta_pitch_window(i), target);
  }

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

size_t VacNetShot::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:VacNetShot)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated float delta_yaw_window = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_delta_yaw_window_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::_pbi::FromIntSize(this->_internal_delta_yaw_window_size());
    total_size += data_size;
  }

  // repeated float delta_pitch_window = 7;
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_delta_pitch_window_size());
    size_t data_size = 4UL * count;
    total_size += 1 *
                  ::_pbi::FromIntSize(this->_internal_delta_pitch_window_size());
    total_size += data_size;
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional fixed64 steamid_player = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional int32 round_number = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_round_number());
    }

    // optional int32 hit_type = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_hit_type());
    }

    // optional int32 weapon_type = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_weapon_type());
    }

    // optional float distance_to_hurt_target = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 4;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData VacNetShot::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    VacNetShot::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*VacNetShot::GetClassData() const { return &_class_data_; }


void VacNetShot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<VacNetShot*>(&to_msg);
  auto& from = static_cast<const VacNetShot&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:VacNetShot)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.delta_yaw_window_.MergeFrom(from._impl_.delta_yaw_window_);
  _this->_impl_.delta_pitch_window_.MergeFrom(from._impl_.delta_pitch_window_);
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_impl_.steamid_player_ = from._impl_.steamid_player_;
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.round_number_ = from._impl_.round_number_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.hit_type_ = from._impl_.hit_type_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.weapon_type_ = from._impl_.weapon_type_;
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_impl_.distance_to_hurt_target_ = from._impl_.distance_to_hurt_target_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

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

void VacNetShot::InternalSwap(VacNetShot* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.delta_yaw_window_.InternalSwap(&other->_impl_.delta_yaw_window_);
  _impl_.delta_pitch_window_.InternalSwap(&other->_impl_.delta_pitch_window_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(VacNetShot, _impl_.distance_to_hurt_target_)
      + sizeof(VacNetShot::_impl_.distance_to_hurt_target_)
      - PROTOBUF_FIELD_OFFSET(VacNetShot, _impl_.steamid_player_)>(
          reinterpret_cast<char*>(&_impl_.steamid_player_),
          reinterpret_cast<char*>(&other->_impl_.steamid_player_));
}

::PROTOBUF_NAMESPACE_ID::Metadata VacNetShot::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_fatdemo_2eproto_getter, &descriptor_table_fatdemo_2eproto_once,
      file_level_metadata_fatdemo_2eproto[9]);
}

// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::MLDict*
Arena::CreateMaybeMessage< ::MLDict >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLDict >(arena);
}
template<> PROTOBUF_NOINLINE ::MLEvent*
Arena::CreateMaybeMessage< ::MLEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::MLMatchState*
Arena::CreateMaybeMessage< ::MLMatchState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLMatchState >(arena);
}
template<> PROTOBUF_NOINLINE ::MLRoundState*
Arena::CreateMaybeMessage< ::MLRoundState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLRoundState >(arena);
}
template<> PROTOBUF_NOINLINE ::MLWeaponState*
Arena::CreateMaybeMessage< ::MLWeaponState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLWeaponState >(arena);
}
template<> PROTOBUF_NOINLINE ::MLPlayerState*
Arena::CreateMaybeMessage< ::MLPlayerState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLPlayerState >(arena);
}
template<> PROTOBUF_NOINLINE ::MLGameState*
Arena::CreateMaybeMessage< ::MLGameState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLGameState >(arena);
}
template<> PROTOBUF_NOINLINE ::MLDemoHeader*
Arena::CreateMaybeMessage< ::MLDemoHeader >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLDemoHeader >(arena);
}
template<> PROTOBUF_NOINLINE ::MLTick*
Arena::CreateMaybeMessage< ::MLTick >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MLTick >(arena);
}
template<> PROTOBUF_NOINLINE ::VacNetShot*
Arena::CreateMaybeMessage< ::VacNetShot >(Arena* arena) {
  return Arena::CreateMessageInternal< ::VacNetShot >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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